{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "2d573288",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import gym\n",
    "import numpy as np\n",
    "from tqdm import tqdm\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torch.distributions import Normal\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import sys \n",
    "sys.path.append(\"..\") \n",
    "import rl_utils"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99da2555",
   "metadata": {},
   "source": [
    "在机器学习和深度学习的上下文中，我们通常不能直接对随机过程进行求导，原因有几点：\n",
    "\n",
    "随机性：随机过程本身包含内在的随机性，其输出是在某个概率分布下随机生成的。这意味着随机过程的输出不是唯一确定的，而是依赖于随机变量或随机噪声的。由于这种随机性，我们不能直接计算随机过程关于某个参数的导数，因为导数是一个确定的量，而随机过程的输出是随机的。\n",
    "\n",
    "非连续性：许多随机过程（如离散时间随机过程）在时间上是不连续的，这意味着它们的输出值在时间点上可能会发生跳变。由于导数是基于极限和连续性的概念定义的，因此我们不能直接对非连续的随机过程求导。\n",
    "\n",
    "不可微分的采样操作：在深度学习中，我们经常需要从某个分布中采样数据点来作为随机变量的实现。然而，采样操作本身是一个不可微分的操作，因为采样结果是一个离散的、随机的值，而不是一个连续可微的函数输出。这导致了我们不能直接对包含采样操作的随机过程进行求导。\n",
    "\n",
    "然而，通过重参数化技巧（Reparameterization Trick），我们可以将随机变量的采样过程转化为一个确定性的、可微分的操作。具体来说，我们引入一个与随机变量同分布的辅助随机变量（如标准正态分布），并使用一个确定性函数（通常是该分布的逆CDF或变换后的CDF）将该辅助随机变量映射到原始随机变量的分布上。这样，我们就可以通过改变确定性函数的参数来间接地改变随机变量的值，并且由于确定性函数是可微分的，我们就可以对整个过程进行求导了。\n",
    "\n",
    "在变分自编码器（VAEs）等模型中，重参数化技巧被广泛应用于处理与随机变量相关的损失函数，从而可以方便地使用基于梯度的优化算法进行训练。通过这种方式，我们可以将随机性引入到模型中，同时仍然能够利用梯度下降等优化算法来优化模型参数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c0fcb00",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PolicyNetContinuous(torch.nn.Module):\n",
    "    '''\n",
    "    1. 策略网络（PolicyNetContinuous）\n",
    "        该网络用于生成连续动作的概率分布，通过重参数化技巧实现可微分采样。\n",
    "        网络结构\n",
    "        输入层：接收状态向量（维度state_dim）。\n",
    "        隐藏层：通过 ReLU 激活的全连接层（维度hidden_dim）。\n",
    "        输出层：\n",
    "        fc_mu：输出动作均值（维度action_dim）。\n",
    "        fc_std：输出动作标准差（维度action_dim），通过 Softplus 确保非负。\n",
    "        动作约束：通过tanh将动作缩放到[-action_bound, action_bound]范围内。\n",
    "        关键技术点\n",
    "        1.重参数化采样（Reparameterization Trick）：\n",
    "            normal_sample = dist.rsample()  # 从N(μ, σ)中采样，保持梯度传递\n",
    "            重参数化采样（rsample()）：\n",
    "                先固定一个 “变异系数”（比如 + 1.5，表示比平均身高高 1.5 个标准差）。\n",
    "                用公式计算身高：身高 = 170 + 10 × 1.5 = 185cm。\n",
    "                这样一来，如果你想让生成的人 “平均高一点”，可以直接调整公式里的170；想让身高差异小一点，可以调整10。梯度就像 “改进建议”，顺着公式传到了这两个参数上。\n",
    "        通过rsample()实现可微分采样，允许梯度从采样动作反向传播到网络参数。\n",
    "        2.Tanh Normal 分布：\n",
    "            action = torch.tanh(normal_sample)  # 将标准正态分布映射到[-1,1]\n",
    "            log_prob = log_prob - torch.log(1 - torch.tanh(action).pow(2) + 1e-7)  # 修正对数概率\n",
    "        tanh将无界的正态分布映射到有界动作空间。\n",
    "        对数概率修正项log(1 - tanh²(x))是为了补偿tanh变换导致的概率密度压缩。\n",
    "        3.动作缩放\n",
    "            action = action * self.action_bound  # 将动作从[-1,1]缩放至实际范围\n",
    "    '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, action_bound):\n",
    "        super().__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc_mu = torch.nn.Linear(hidden_dim, action_dim)\n",
    "        self.fc_std = torch.nn.Linear(hidden_dim, action_dim)\n",
    "        self.action_bound = action_bound\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        mu = self.fc_mu(x)\n",
    "        std = F.softplus(self.fc_std(x))\n",
    "        dist = Normal(mu, std)\n",
    "        # rsample()是重参数化采样\n",
    "        normal_sample = dist.rsample()\n",
    "        '''\n",
    "        重参数化梯度\n",
    "            重参数化技巧使得策略梯度可以表示为：\n",
    "            ∇_θ J(π_θ) ≈ E[∇_a(Q(s,a)-α·logπ(a|s))·∇_θμ_θ(s) + ∇_θσ_θ(s)]\n",
    "            这种形式避免了传统策略梯度的高方差问题，提高了训练稳定性。\n",
    "        '''\n",
    "        log_prob = dist.log_prob(normal_sample)\n",
    "        action = torch.tanh(normal_sample)\n",
    "        # 计算tanh_normal分布的对数概率密度\n",
    "        '''\n",
    "        通过tanh将无界的高斯样本映射到 [-1,1] 区间\n",
    "        乘以action_bound将动作缩放到实际范围\n",
    "        对数概率修正项log(1-tanh²(a))来源于变量替换的雅可比行列式\n",
    "        Tanh-Normal 分布\n",
    "            当对高斯分布采样结果应用 tanh 变换时，动作概率密度函数需要修正：\n",
    "            p(a|s) = p_normal(z|s) / |1-tanh²(z)|\n",
    "            其中 z 是 tanh 的逆变换：z = atanh (a/action_bound)\n",
    "        '''\n",
    "        log_prob = log_prob - torch.log(1 - torch.tanh(action).pow(2) + 1e-7)\n",
    "        action = action * self.action_bound\n",
    "        return action, log_prob\n",
    "\n",
    "class QValueNetContinuous(torch.nn.Module):\n",
    "    '''\n",
    "    网络结构与输入\n",
    "        输入层拼接状态向量 (维度state_dim) 和动作向量 (维度action_dim)\n",
    "        两层隐藏层，维度均为hidden_dim\n",
    "        输出层为标量 Q 值，表示该状态 - 动作对的预期累积回报\n",
    "    设计特点\n",
    "        使用 ReLU 激活函数引入非线性\n",
    "        采用多层感知机 (MLP) 结构，适合处理连续状态和动作空间\n",
    "        输出层无激活函数，允许 Q 值在实数域内取值\n",
    "    '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim + action_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.fc_out = torch.nn.Linear(hidden_dim, 1)\n",
    "    \n",
    "    def forward(self, x, a):\n",
    "        cat = torch.cat([x, a], dim=1)\n",
    "        x = F.relu(self.fc1(cat))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        return self.fc_out(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db5d1b59",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SACContinuous:\n",
    "    ''' 处理连续动作的SAC算法 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, action_bound, actor_lr, critic_lr, alpha_lr, target_entropy, tau, gamma, device):\n",
    "        '''初始化：创建策略网络、两个 Q 值网络及对应的目标网络，同时初始化优化器和超参数。'''\n",
    "        # 策略网络\n",
    "        self.actor = PolicyNetContinuous(state_dim, hidden_dim, action_dim, action_bound).to(device)\n",
    "        # 第一个Q网络\n",
    "        self.critic_1 = QValueNetContinuous(state_dim, hidden_dim, action_dim).to(device)\n",
    "        # 第二个Q网络\n",
    "        self.critic_2 = QValueNetContinuous(state_dim, hidden_dim, action_dim).to(device)\n",
    "        # 第一个目标Q网络\n",
    "        self.target_critic_1 = QValueNetContinuous(state_dim, hidden_dim, action_dim).to(device)\n",
    "        # 第二个目标Q网络\n",
    "        self.target_critic_2 = QValueNetContinuous(state_dim, hidden_dim, action_dim).to(device)\n",
    "        # 令目标Q网络的初始参数和Q网络一样\n",
    "        self.target_critic_1.load_state_dict(self.critic_1.state_dict())\n",
    "        self.target_critic_2.load_state_dict(self.critic_2.state_dict())\n",
    "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=actor_lr)\n",
    "        self.critic_1_optimizer = torch.optim.Adam(self.critic_1.parameters(), lr=critic_lr)\n",
    "        self.critic_2_optimizer = torch.optim.Adam(self.critic_2.parameters(), lr=critic_lr)\n",
    "        # 使用alpha的log值,可以使训练结果比较稳定\n",
    "        self.log_alpha = torch.tensor(np.log(0.01), dtype=torch.float)\n",
    "        # 可以对alpha求梯度\n",
    "        self.log_alpha.requires_grad = True \n",
    "        self.log_alpha_optimizer = torch.optim.Adam([self.log_alpha], lr=alpha_lr)\n",
    "        # 目标熵的大小\n",
    "        self.target_entropy = target_entropy\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):\n",
    "        '''动作选择：take_action方法依据当前状态，通过策略网络采样得到动作。'''\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        action = self.actor(state)[0]\n",
    "        return [action.item()]\n",
    "    \n",
    "    def calc_target(self, rewards, next_states, dones):\n",
    "        # 计算目标Q值\n",
    "        '''\n",
    "        目标计算：calc_target方法计算目标 Q 值，融入了熵正则化项。\n",
    "        目标 Q 值计算的核心思想\n",
    "        SAC 算法通过最大化以下目标函数来优化策略：\n",
    "            J(π) = E[Σ γ^t (r(s,a) + αH(π(·|s_t)))]\n",
    "        其中 H (π) 是策略熵，α 是温度参数，控制探索与利用的平衡。\n",
    "        代码中的calc_target函数正是计算这个优化目标的 TD 目标值。\n",
    "        '''\n",
    "        next_actions, log_prob = self.actor(next_states)\n",
    "        ''' \n",
    "        获取下一状态的动作和对数概率\n",
    "            通过策略网络 (actor) 生成下一状态的动作分布采样\n",
    "            同时获取该动作的对数概率密度 (log_prob)\n",
    "        '''\n",
    "        entropy = -log_prob\n",
    "        '''\n",
    "        计算熵值\n",
    "            用负对数概率近似表示策略熵\n",
    "            在高斯分布假设下，这等价于对动作分布随机性的度量\n",
    "        '''\n",
    "        q1_value = self.target_critic_1(next_states, next_actions)\n",
    "        q2_value = self.target_critic_2(next_states, next_actions)\n",
    "        '''\n",
    "        双 Q 网络估计\n",
    "        使用两个目标 Q 网络分别评估下一状态动作对的值\n",
    "        双 Q 结构是 SAC 算法的改进，用于缓解 Q 值高估问题\n",
    "        '''\n",
    "        next_value = torch.min(q1_value, q2_value) + self.log_alpha.exp() * entropy\n",
    "        '''\n",
    "        最小化 Q 值估计torch.min(q1_value, q2_value)\n",
    "            取两个 Q 网络估计值的最小值\n",
    "            这是 Double Q-Learning 的变体，能有效减少过估计偏差\n",
    "        加入策略熵作为正则化项self.log_alpha.exp() * entropy\n",
    "            α(温度参数) 控制熵项的重要性，这里通过指数化 log_alpha 确保 α 为正\n",
    "            熵项鼓励策略保持高随机性，提高探索能力\n",
    "        '''\n",
    "        td_target = rewards + self.gamma * next_value * (1 - dones)\n",
    "        '''\n",
    "        构建 TD 目标\n",
    "            标准的贝尔曼目标结构\n",
    "            gamma 是折扣因子，衰减未来回报的重要性\n",
    "            (1-dones) 确保在终止状态下不计算未来回报\n",
    "        '''\n",
    "        return td_target\n",
    "    \n",
    "    def soft_update(self, net, target_net):\n",
    "        '''软更新：soft_update方法按照 Polyak 平均方式更新目标网络参数。'''\n",
    "        for param_target, param in zip(target_net.parameters(), net.parameters()):\n",
    "            param_target.data.copy_(param_target.data * (1.0 - self.tau) + param.data * self.tau)\n",
    "    \n",
    "    def update(self, transition_dict):\n",
    "        '''参数更新：update方法实现策略、Q 值网络和温度参数（α）的更新'''\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        # 和之前章节一样,对倒立摆环境的奖励进行重塑以便训练\n",
    "        rewards = (rewards + 8.0) / 8.0\n",
    "\n",
    "        # 更新两个Q网络\n",
    "        '''\n",
    "        Q 网络通过最小化贝尔曼误差更新：\n",
    "            L(θ) = E[(Q_θ(s,a) - (r + γ·E_{a'~π}[Q_θ'(s',a') - α·logπ(a'|s')]))²]\n",
    "            使用目标网络 Q_θ' 计算目标值\n",
    "            包含熵正则化项，降低确定性策略过拟合风险\n",
    "        '''\n",
    "        td_target = self.calc_target(rewards, next_states, dones)\n",
    "        critic_1_loss = torch.mean(F.mse_loss(self.critic_1(states, actions), td_target.detach()))\n",
    "        critic_2_loss = torch.mean(F.mse_loss(self.critic_2(states, actions), td_target.detach()))\n",
    "        self.critic_1_optimizer.zero_grad()\n",
    "        self.critic_2_optimizer.zero_grad()\n",
    "        critic_1_loss.backward()\n",
    "        critic_2_loss.backward()\n",
    "        self.critic_1_optimizer.step()\n",
    "        self.critic_2_optimizer.step()\n",
    "\n",
    "        # 更新策略网络\n",
    "        '''\n",
    "        策略网络通过最大化以下目标更新：\n",
    "            max E[Q(s,a) + α·logπ(a|s)]\n",
    "            从当前策略采样动作 a\n",
    "            利用 Q 网络评估动作价值\n",
    "            熵项鼓励策略保持高随机性\n",
    "        '''\n",
    "        new_actions, log_prob = self.actor(states)\n",
    "        entropy = -log_prob\n",
    "        q1_value = self.critic_1(states, new_actions)\n",
    "        q2_value = self.critic_2(states, new_actions)\n",
    "        # actor_loss = torch.mean(self.log_alpha.exp() * log_prob - torch.min(q1_value, q2_value))\n",
    "        actor_loss = torch.mean(-self.log_alpha.exp() * entropy - torch.min(q1_value, q2_value))\n",
    "        '''\n",
    "        # 要最大化 J(π)，等价于最小化 -J(π)\n",
    "        J(π) = E[Q(s,a) - αlogπ(a|s)]\n",
    "        actor_loss = -J(π) = -E[Q(s,a) - α·logπ(a|s)] = E[α·logπ(a|s) - Q(s,a)]\n",
    "        代码中entropy = -log_prob，因此-α·entropy = α·logπ(a|s)\n",
    "        '''\n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "\n",
    "        # 更新alpha值\n",
    "        alpha_loss = -torch.mean((self.target_entropy + log_prob).detach() * self.log_alpha.exp())\n",
    "        self.log_alpha_optimizer.zero_grad()\n",
    "        alpha_loss.backward()\n",
    "        self.log_alpha_optimizer.step()\n",
    "        '''\n",
    "        计算 α 的损失函数\n",
    "            entropy：当前策略的熵（由策略网络计算）\n",
    "            self.target_entropy：目标熵，通常设为-动作空间维度\n",
    "            self.log_alpha.exp()：温度参数 α（通过对 log_alpha 取指数确保 α 为正）\n",
    "            .detach()：阻止梯度流向熵计算部分\n",
    "        自适应 α 的数学原理\n",
    "            优化目标\n",
    "            α 的学习目标是最小化以下损失函数：\n",
    "                J(α) = E[-α * (logπ(a|s) + H_target)]\n",
    "            其中，H_target是目标熵（通常设为-动作空间维度）。\n",
    "            梯度推导\n",
    "            对 J (α) 求导可得：\n",
    "                ∇α J(α) = -1 * E[(logπ(a|s) + H_target)]\n",
    "            用熵表示梯度\n",
    "                注意到策略的熵H(π)定义为：H(π) = -E_a~π[logπ(a|s)]\n",
    "                因此：E[logπ(a|s)] = -H(π)\n",
    "                将梯度表达式中的 E[logπ(a|s)] 替换为 -H(π)：\n",
    "                 ∇α J(α) = H(π) - H_target\n",
    "            在代码中，我们通常优化 log_α 而非直接优化 α，这样可以确保 α 始终为正值。设z=log_α，则 α = e^z。\n",
    "            使用链式法则计算关于 z 的梯度：∇z J(z) = ∇J/∇α * ∇α/∇z = (H(π) - H_target) * e^z\n",
    "            对应代码中的：\n",
    "                (entropy - self.target_entropy) * self.log_alpha.exp()\n",
    "            直观理解\n",
    "                若当前策略的熵 低于目标熵（探索不足），则 减小 α（降低熵的权重，间接鼓励探索）。\n",
    "                若当前策略的熵 高于目标熵（探索过度），则 增大 α（提高熵的权重，抑制过度探索）。\n",
    "        为什么使用 log_alpha 而非直接优化 α？\n",
    "            代码中优化的是log_alpha而非 α 本身，主要原因是：\n",
    "            数值稳定性：直接优化 α 可能导致其值为负或过大，而 log_alpha 可通过指数函数自然约束 α 为正。\n",
    "            梯度稳定性：对 log_alpha 求导能避免 α 接近 0 时的梯度爆炸问题。\n",
    "        目标熵的选择\n",
    "            目标熵通常设为：\n",
    "                self.target_entropy = -torch.prod(torch.Tensor(self.action_dim)).item()\n",
    "            # 对于一维动作空间，目标熵为 -1.0\n",
    "        这一选择的依据是：\n",
    "            当策略为均匀分布时，熵最大\n",
    "            目标熵设为动作维度的负值，可使策略保持适当的随机性\n",
    "        自适应 α 的优势\n",
    "            自动平衡探索与利用：无需手动调整 α，算法可根据环境复杂度自动适应。\n",
    "            提高样本效率：在学习初期鼓励探索，后期专注利用。\n",
    "            改善稳定性：防止策略过早收敛到次优解。\n",
    "        '''\n",
    "        self.soft_update(self.critic_1, self.target_critic_1)\n",
    "        self.soft_update(self.critic_2, self.target_critic_2)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c52edebc",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0:   0%|          | 0/10 [00:00<?, ?it/s]/tmp/ipykernel_1066/1532782166.py:34: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /pytorch/torch/csrc/utils/tensor_new.cpp:254.)\n",
      "  state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
      "Iteration 0: 100%|██████████| 10/10 [00:11<00:00,  1.18s/it, episode=10, return=-1512.876]\n",
      "Iteration 1: 100%|██████████| 10/10 [00:21<00:00,  2.20s/it, episode=20, return=-931.226]\n",
      "Iteration 2: 100%|██████████| 10/10 [00:22<00:00,  2.29s/it, episode=30, return=-291.928]\n",
      "Iteration 3: 100%|██████████| 10/10 [00:23<00:00,  2.30s/it, episode=40, return=-200.643]\n",
      "Iteration 4: 100%|██████████| 10/10 [00:22<00:00,  2.30s/it, episode=50, return=-177.334]\n",
      "Iteration 5: 100%|██████████| 10/10 [00:22<00:00,  2.25s/it, episode=60, return=-154.872]\n",
      "Iteration 6: 100%|██████████| 10/10 [00:23<00:00,  2.32s/it, episode=70, return=-162.922]\n",
      "Iteration 7: 100%|██████████| 10/10 [00:23<00:00,  2.34s/it, episode=80, return=-135.381]\n",
      "Iteration 8: 100%|██████████| 10/10 [00:23<00:00,  2.35s/it, episode=90, return=-149.141]\n",
      "Iteration 9: 100%|██████████| 10/10 [00:24<00:00,  2.40s/it, episode=100, return=-153.069]\n"
     ]
    }
   ],
   "source": [
    "env_name = 'Pendulum-v1'\n",
    "env = gym.make(env_name)\n",
    "state_dim = env.observation_space.shape[0]\n",
    "action_dim = env.action_space.shape[0]\n",
    "#动作最大值\n",
    "action_bound = env.action_space.high[0]\n",
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "torch.manual_seed(0)\n",
    "\n",
    "actor_lr = 3e-4\n",
    "critic_lr = 3e-3\n",
    "alpha_lr = 3e-4\n",
    "num_episodes = 100\n",
    "hidden_dim = 128\n",
    "gamma = 0.99\n",
    "# 软更新参数\n",
    "tau = 0.005\n",
    "buffer_size = 100000\n",
    "minimal_size = 1000\n",
    "batch_size = 64\n",
    "target_entropy = -env.action_space.shape[0]\n",
    "device = 'cpu'\n",
    "replay_buffer = rl_utils.ReplayBuffer(buffer_size)\n",
    "agent = SACContinuous(state_dim, hidden_dim, action_dim, action_bound, actor_lr, critic_lr, alpha_lr, target_entropy, tau, gamma, device)\n",
    "return_list = rl_utils.train_off_policy_agent(env, agent, num_episodes, replay_buffer, minimal_size, batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3cdfe527",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlAAAAHHCAYAAABwaWYjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjI9JREFUeJzt3Xe80/X1P/BXdu7em8vlsvcQBAGVIQr+bC1WKVqxgHvgV8FRsC3UOnAU1CqVWkW0aqW42ooLEbUqqIyLskHW5XInd+TO5Cb5/P5I3p/s3OSSezN4PR+P+9CbfG7ySe4lOTnnvM9bIUmSBCIiIiIKmDLcJ0BEREQUbRhAEREREQWJARQRERFRkBhAEREREQWJARQRERFRkBhAEREREQWJARQRERFRkBhAEREREQWJARQRERFRkBhAERF1s8mTJ2Py5Mmd+tl58+ahV69eIT0fIgoeAyiis8CPP/6Iq666CkVFRdDr9SgoKMDFF1+MZ5991ufP/OpXv4JCocBvf/tbv7ddUlKCOXPmoLCwEDqdDunp6Zg2bRpefvllWCyWUD+UTunVqxcUCoX8lZ2djQsuuADvvvtuuE/trLJu3TrMmTMH/fr1g0Kh6HQQSRQJGEARxbhvvvkGY8aMwa5du3DTTTfhueeew4033gilUolnnnnG688YDAb897//Ra9evfDPf/4TvrbMfPHFFzFmzBhs3rwZ1157Lf76179i6dKliIuLww033IDHH3+8Kx9aUEaOHIl//OMf+Mc//oF7770Xp06dwi9/+UusXr063Kd21nj++efx73//G4WFhUhLSwv36RCdEXW4T4CIutYjjzyClJQUfP/990hNTXW5rqqqyuvPvP3227BYLFizZg2mTp2KL7/8EpMmTXI5ZuvWrbj11lsxfvx4fPDBB0hKSpKvu/vuu7Ft2zbs3r075I+nswoKCjBnzhz5+9/85jfo27cvnnrqKdx6661hPLOzxz/+8Q8UFBRAqVRi6NCh4T4dojPCDBRRjPvpp58wZMgQj+AJALKzs73+zOuvv46LL74YU6ZMwaBBg/D66697HPPggw9CoVDg9ddfdwmehDFjxmDevHkdnt9f//pXDBkyBDqdDvn5+bjjjjtQX1/vcszkyZMxdOhQ7N27F1OmTEF8fDwKCgrwxBNPdHj7vuTm5mLQoEE4evSofFlZWRmuv/565OTkQKfTYciQIVizZo3Lz33++edQKBT417/+hUceeQQ9evSAXq/HRRddhMOHD3vczwsvvIA+ffogLi4OY8eOxf/+9z+PY9auXQuFQoFjx455va/PP//c5+PwdcyxY8egUCiwdu1a+bJ58+YhMTERJ06cwM9+9jMkJiaioKAAq1atAmAr9U6dOhUJCQkoKirCG2+84fN+haFDh2LKlCkel1utVhQUFOCqq66SLyssLIRSybcdig38SyaKcUVFRdi+fXvA2aBTp05h8+bNuOaaawAA11xzDd566y2YTCb5mJaWFmzatAkXXnghevbs2elz++Mf/4g77rgD+fn5WLFiBa688kr87W9/wyWXXIL29naXY+vq6jBjxgyMGDECK1aswMCBA/Hb3/4WH374Yafuu729HaWlpcjIyAAAVFZW4rzzzsOnn36KBQsW4JlnnkHfvn1xww034Omnn/b4+cceewzvvvsu7r33XixZsgRbt27Ftdde63LMSy+9hFtuuQW5ubl44oknMHHiRFx++eUoLS3t1DmHgsViwaWXXorCwkI88cQT6NWrFxYsWIC1a9dixowZGDNmDB5//HEkJSXhN7/5jUuA6c3s2bPx5ZdfoqKiwuXyr776CqdOncLVV1/dlQ+HKHwkIoppn3zyiaRSqSSVSiWNHz9euv/++6WPP/5YMplMXo//85//LMXFxUkGg0GSJEk6ePCgBEB699135WN27dolAZDuuuuuTp9XVVWVpNVqpUsuuUSyWCzy5c8995wEQFqzZo182aRJkyQA0quvvipfZjQapdzcXOnKK6/s8L6KioqkSy65RKqurpaqq6ulXbt2SVdffbUEQLrzzjslSZKkG264QcrLy5Nqampcfvbqq6+WUlJSpJaWFkmSJGnz5s0SAGnQoEGS0WiUj3vmmWckANKPP/4oSZIkmUwmKTs7Wxo5cqTLcS+88IIEQJo0aZJ82csvvywBkI4ePepy3+K+Nm/eLF82d+5cqaioyO8xkiRJR48elQBIL7/8ssvPApAeffRR+bK6ujopLi5OUigU0ptvvilfvn//fgmAtGzZMp/PqyRJ0oEDByQA0rPPPuty+e233y4lJibKz5u7IUOGuDwHRNGGGSiiGHfxxRdjy5YtuPzyy7Fr1y488cQTmD59OgoKCvCf//zH4/jXX38dl112mVyW69evH0aPHu1SxjMYDADgtXQXqE8//RQmkwl33323S1nnpptuQnJyMjZs2OByfGJioksPk1arxdixY3HkyJGA7u+TTz5BVlYWsrKyMGLECKxfvx7XXXcdHn/8cUiShLfffhs///nPIUkSampq5K/p06ejoaEBO3bscLm9+fPnQ6vVyt9fcMEFACCfz7Zt21BVVYVbb73V5bh58+YhJSUlwGepa9x4443y/6empmLAgAFISEjAr371K/nyAQMGIDU1tcPnt3///hg5ciTWrVsnX2axWPDWW2/h5z//OeLi4kL/AIgiAJvIic4C5557Lt555x2YTCbs2rUL7777Lp566ilcddVVKCkpweDBgwEA+/btw86dO/Gb3/zGpZ9n8uTJWLVqFQwGA5KTk5GcnAwAaGxs7PQ5HT9+HIDtjdqZVqtF79695euFHj16QKFQuFyWlpaGH374IaD7GzduHB5++GEoFArEx8dj0KBBcl9YVVUV6uvr8cILL+CFF17w+vPuDffupUuxqqyurs7l8fXr18/lOI1Gg969ewd0zl1Br9cjKyvL5bKUlBSvz29KSor8eCwWC6qrq12uT09Ph1arxezZs/HAAw+grKwMBQUF+Pzzz1FVVYXZs2d37YMhCiMGUERnEa1Wi3PPPRfnnnsu+vfvj/nz52P9+vVYtmwZAOC1114DACxcuBALFy70+Pm3334b8+fPR9++faFWq/Hjjz9227mrVCqvl0s+Riy4y8zMxLRp07xeZ7VaAQBz5szB3LlzvR4zfPjwkJ6PM/fARQhkjlawP+vrvDt6PKWlpSguLna5bvPmzZg8eTJmz56NJUuWYP369bj77rvxr3/9CykpKZgxY0aH508UrRhAEZ2lxowZAwAoLy8HYHujfOONNzBlyhTcfvvtHsc/9NBDeP311zF//nzEx8dj6tSp+Oyzz1BaWorCwsKg77+oqAgAcODAAZeMjMlkwtGjR30GO10hKysLSUlJsFgsIbtf8fgOHTqEqVOnype3t7fj6NGjGDFihHyZyF65rz50z8J5cyY/G4zc3Fxs3LjR5TLxGIqLizF27FisW7cOCxYswDvvvIOZM2dCp9OF9ByIIgl7oIhi3ObNm71mRT744AMAjhLa119/jWPHjmH+/Pm46qqrPL5mz56NzZs349SpUwCAZcuWQZIkXHfddWhqavK4/e3bt+OVV17xeV7Tpk2DVqvFX/7yF5fze+mll9DQ0IDLLrvsjB53MFQqFa688kq8/fbbXlcrupeuAjFmzBhkZWVh9erVLisY165d6xHs9OnTBwDw5ZdfypdZLBaf5URnRUVFUKlULj8L2MZDhJJer8e0adNcvpyHYc6ePRtbt27FmjVrUFNTw/IdxTxmoIhi3J133omWlhZcccUVGDhwIEwmE7755husW7cOvXr1wvz58wHYmsdVKpXPwOXyyy/H7373O7z55ptYtGgRJkyYgFWrVuH222/HwIEDcd1116Ffv35obGzE559/jv/85z94+OGHfZ5XVlYWlixZggcffBAzZszA5ZdfjgMHDuCvf/0rzj33XJeG8e7w2GOPYfPmzRg3bhxuuukmDB48GLW1tdixYwc+/fRT1NbWBnV7Go0GDz/8MG655RZMnToVs2fPxtGjR/Hyyy979EANGTIE5513HpYsWYLa2lqkp6fjzTffhNls7vB+UlJSMGvWLDz77LNQKBTo06cP3n//fZ9DUrvKr371K9x7772499575e183H355ZdyoFddXY3m5mb5b+TCCy/EhRde2K3nTHRGwrb+j4i6xYcffihdf/310sCBA6XExERJq9VKffv2le68806psrJSkiTbkvuMjAzpggsu8HtbxcXF0qhRo1wu2759u/TrX/9ays/PlzQajZSWliZddNFF0iuvvOIynsCX5557Tho4cKCk0WiknJwc6bbbbpPq6upcjpk0aZI0ZMgQj591X9LvS1FRkXTZZZd1eFxlZaV0xx13SIWFhZJGo5Fyc3Oliy66SHrhhRfkY8TYgPXr17v8rLexAZIkSX/961+l4uJiSafTSWPGjJG+/PJLadKkSR5L+H/66Sdp2rRpkk6nk3JycqQHHnhA2rhxY4djDCRJkqqrq6Urr7xSio+Pl9LS0qRbbrlF2r17t9cxBgkJCR6P29fzG+jzJkycOFECIN14441er1+2bJkEwOtXR+MSiCKNQpI60fFIREREdBZjDxQRERFRkBhAEREREQWJARQRERFRkBhAEREREQWJARQRERFRkBhAEREREQWJgzS7gNVqxalTp5CUlORznyoiIiKKLJIkobGxEfn5+VAq/eeYGEB1gVOnTnVqbzAiIiIKv9LSUvTo0cPvMQygukBSUhIA2y8gOTk5zGdDREREgTAYDCgsLJTfx/1hANUFRNkuOTmZARQREVGUCaT9hk3kREREREFiAEVEREQUJAZQREREREFiAEVEREQUJAZQREREREFiAEVEREQUJAZQREREREFiAEVEREQUJAZQREREREFiAEVEREQUJAZQPqxatQq9evWCXq/HuHHj8N1334X7lIiIiChCMIDyYt26dVi0aBGWLVuGHTt2YMSIEZg+fTqqqqrCfWpEREQUARhAebFy5UrcdNNNmD9/PgYPHozVq1cjPj4ea9asCfepERGRDxarFO5TcGE0WyLunLqKJElnzWMV1OE+gUhjMpmwfft2LFmyRL5MqVRi2rRp2LJli9efMRqNMBqN8vcGg6HLz5MoEv3188M4XtOCx64cFtBu5sH46lANclN06JudFNLbpej0r22l+OZwDSoNRlQa2lBpaEO7RcIzV4/EpcPywn16MJotmPrnL5Aar8H7d54f8n8PkWbhuhJsOXIanyychJQ4TcA/99n+SvRMT0Df7MQuPLuuwQyUm5qaGlgsFuTk5LhcnpOTg4qKCq8/s3z5cqSkpMhfhYWF3XGq1M3e3n4St7++HW3tlnCfSkRqNprx548PYN22UvxU3RzS2z5Z14I5L32Lm17dHtLbjTVl9a0wma3hPo0uV1bfivvf+gHvlZzCliOncaSmGc0mC0wWK/77w6lwnx4A4PjpFpTVt2LPKQNO1rWG+3S63Kb9Vag0GLGnrCHgn/nhZD2uX7sNt74Wnf+uGUCFwJIlS9DQ0CB/lZaWhvuUqAv87cuf8MGPFfj+WG24TyUi7S5rgMjg1zabQnrb4g3o2OlmmC2xHyB0xr5yAyY+9hkW/qsk3KfS5UpO1AMAijLi8czVI/Hmzedh5a9GAAB+DOINvCtVNLTJ/7/rZH34TqQbGM0WNLaZAQAVhrYOjnbYeuQ0AOBwVRNONxk7ODrysITnJjMzEyqVCpWVlS6XV1ZWIjc31+vP6HQ66HS67jg9CqNmoy3zJF4oyFVJab38/6EOoOrstydJwOlmE3KS9SG9/VggAocfT0ZGANGVREByQb9M/GJkAQCgobUdAFBa24r6FhNS47XhOj0AroHEDycb8LPh+WE8m65V19wu/395Q+ABlPNrRklpPS4alOP74AjEDJQbrVaL0aNHY9OmTfJlVqsVmzZtwvjx48N4ZhRuonTXZGQA5Y3zp+y6lhAHUC2OF+jKID7hnk2q7M9LRUMbrDHezCveeEf0SJUvS4nToCgjHkBkZKGcM1DOgUIsqnHKHgXz71NkEoHofI4YQHmxaNEi/P3vf8crr7yCffv24bbbbkNzczPmz58f7lOjMGq1B1DNDKC8cn4xDHkGyikgqzJEX6q/O1TanxeTxYraEAewkcRsscpZtpGFqS7XDS1IARAhAZRTILG7rCGmV6iddvr3XhFgBqrS0IZTUR5ksoTnxezZs1FdXY2lS5eioqICI0eOxEcffeTRWE5nD0mSGED5UeX2YljXRSU8AKhqZADljfMbdkVDGzITY7Ot4HB1E1rbLUjUqdE7y3Xl1rCCFGz4oRy7IyCAqnT699BisuCn6ib0z4nNFaS1zcFnoHbaP3DFa1VoMVlQUloPq1WCUhk9qxWZgfJhwYIFOH78OIxGI7799luMGzcu3KdEYWQ0WyHZP0A2GbkKz537p8dQZ0BYwutYldPzcqo+dld97bL/rQ0rSIHK7c12eARloEQvkNp+jruiMMMSqNNNjn/vgfZAideMy4blQa9RorHNjCM1oV2929UYQBEFoNXkCJqYgfIkXgz1GttLSqgzUPUtzEB1pNKptBnMSqhoU1JqC45GuJXvAGCIPYASjeThJAL98X0yAMT2SrwapwCqpskY0ErZktI6AMCYXmkYZv+9RVsZjwEUUQBa2xlA+SPeHCb2yQQQ+h4o54xWdWPsBgedZbFKqHZq5A1mJVS0EZmckYUpHtc5N5LvLgvfQGOj2SL3BV0yxLZ6+4cYXh3pPILAKsHlb9Ebi1WSn4+RhWlyL5sIqqIFAyiiADgHUFyF58pqlfCDPSswZWA2gNCX8OpdSnjMQLk73WR0aVIuj9ESXqvJggOVjQC8Z6AARyP5D2X13XRWnsRCB61aiUn9sgDY5nQZzbFZ/nf/wNRRAH+wshEtJgsStCr0zU7EyMI0AMxAEcUklxKeiQGUs5+qm9BoNCNOo8J5vdMBuM6FCQWXVXjMQHlwDypjNQO155RtNVt2kg65PmaBiXJQOBvJRQk1N1mPwvQ4pCdo0W6RsL+8MWzn1JVq3AKoyg7+/uQxFIWpUCkVGNkzFQCwv7wxqnZ6YABFFADXDFT0/APvDiVOTb1ZibY3tSajOWSfti1WSR6SCNj6LWJ5SXhniDds0VMdqz1Qzm+8vvaWGxYBjeQigM1N0UOhUGB4D9s5xWoflCjhiaC2o78/MfJElO7yU/TIStLBbJUiYgVloBhAEQWATeS+iTe1kT1TkaRXyyujnMtuZ6KhtV1eAalQ2AKq080s4zkTDctimXx5QxskKfaCzF0+5j85G5of/kZykYERAcVw+8DPXaXRExwEQ6zCG5KfDCCAAEruY0sFACgUCqc+qPquOMUuwQCKKABsIvdNfKoe0SMVSqUCafG2ndhD1UguyndJejUyEmyzjThM05UYYTCiRyoUCsBktoa8kT8S7PIygdxdSrwGPdPD20gul/BSbAHUCHsG6ocYzEC1mMzy66NYBelvmGZjWzsOVtlKmaJ0BziCqZ0MoIhii3MGik3kDm3tFrmvQ7wYptn3IAtZAGW/nbR4LXKSbQFUNUcZuBBv2D3S4uQBmrHWB1XbbMKJ2hYAwLAenivwnInrw9VIXuEjA3W4uinmXj9E9kmrVqJPVgIA/wHUjycbIElAQWocspMcfWxyBsppR4NIxwCKKADuGahYLI90xu6yBpitErKSdMi3f9pOSwhxAGUvBabFa5CdZAsOOEzTlWgiz0nWI8/+ewh0S41oITKdvbMSkBKn8XtsuBvJ3TNQWUk6FKTGQZJib7NnMa4hM0ErB4z+/n3udCr5OxveIwUKBVBW3xo1H5AYQBEFwDkDZZVcA6qzmfOmrqKpN8MeQIVqQ2FxO2kJWvkTK4dpuhJvWDkpevlNrLwhtkYZyPOf/JTvhHA3kovgNcdppeDwGC3jiQbyjESdHDD668ETW7iMcutjS9Jr0Ne+NU+0TG1nAEUUAPeAKdbS8J0lAqhRTp8mQ56B8lLC4ygDV3IAlayTM1CxVsLb5bQCryPhbCS3WiX59yF+F4CjjBdrAzVFBiojUSsHjEaz1WXlrCBJktfXDCHaGskZQBEFwDkDBQDNHGUAwLWBXEi390CFajsXUcJLjdcgSy4RMAMlGM0W+TnKSdIjLzUOQGyV8CRJklfgBRJAhbOR/HSzCWarBIXCVroTRhRG53YlHRE9UOkJWug1KnkRibeVeGX1rahpMkKtVGBIvmcfmyjrRctzxACKKADuGahoWonX2NYOaxfMTTrdZERpra1MNNxpWw05A+VjjEFDSzv2njIE3EcmMgjp8Vq5B4olPAfnqdep8Ro563HqDEp4zUYzGkI0hiIUTta1orbZBI1KgUF5SQH9TLjKeCJwzUzUQaNyvMUOK3D0+JzuYKuTjkiShM0HqvC/Q9Xdstqy3WL1OeBSPBaxeEFkobwF8CIwGpSXDL1G5XG9yEDtKq3vktesUFOH+wSIokF3l/DqW0xY8/Ux1DWbYDRbYDRbYWy3on9OIhZe3N/nEEF3x0834+KVX+LSYbl45upRIT1H8WLYJysByXpHU296gu3/fWWgbnltG7YeqcXoojTcdVE/XNAv0+/jEW8QqQmOEkF1CJrIJUlCTZMJR2uaUdXYhvP7ZiLVnj3rSh/tLseeUwakxGmQGq9FapwG6YlaDPbxptIR5/KdQqFwDDMMMgNV3WjExr2V+GhPBb45XAOzVUJqvAa9MhLQKyMefbMTMee8om55jtyJv7XBecnQqQN7joYWpGDDj+X40c9KvCajGZ/sqUBVoxHn9krD8B6pLkFPZ1R4Kd8Bth6f3pkJ+Km6GR/srsB5xenQa1SI06qQEqcJ6n6/PFSD+S9/L3+fn6LH4PwUjCtOx/yJvaD2cVsmsxWVhjYU2rNzgZAkCT/7y1cwtLVj872TPf5G5RKe/YNTXooe+ysavf79yf1PXsp3ADAgJwlxGhUajWZ8uLsCPdLioFYpoFEpUZQRH/DvvrswgCIKQJtHCa9rA6iXvz6Gv2w65HH5R3tsm5OK/b46UlJaD5PFii8OVkOSpIADr72nDFj9xU/4/WWDkO1jywxRGnEvqYgxBqd9BFB7Ttl+bvvxOvxmzXcYWZiKu6b1w+T+WV7PTwzkdM9AWa0SlErH8e0WK658/hvo1Sq8efN5Ltc5e+WbY3h7x0kcrW5Go9Pv8ZfnFGDlr0Z6/Rl/JEnCgcpGfLKnEl8dqsGUgdm4bXIfr8eebjLi9td3wNuHa71GiXHFGbigXyYm9c9C3+xEtJgsaGwzo7GtHSaLFQNykjzeHOUVePYG+3x7CU808nb0O99d1oA//Xcvvj9eC/ekYH1LO0pa6uUAxtBmxgP/b5DX26ltNuHhDXuRkaDFub3ScW6vdDkb6U9buwW7yxpcpstLAMrqWnGoqgmHKhsDGqDpTmSgdpU24GhNM9LjtUjSq2GVJPzvUA3e3VmGT/ZWoK3dKv9Mok6NccXpmNg3EzNHFSA9gPN3V2HwbCAXRvRIxU/VzfjDe7tdLteqlRiSn4yRhakY1TMNowpT/QY5W346DQCI16rQYrLgVEMbTjW04dN9lSjOTMC0wTlef+6ZTQexavNPeGnuGFw0yPsx7kprW+X9B4/WNGNQXrLL9Y4eKNu/TdFI7q2E5z5A051apcSwghR8d6wWd7yxw+W6gblJ+PCuCwJ+DesODKCIAtDdGSjRW3TJ4ByMKEyFTq3EW9tPYn9FI3442RBwACXKO/Ut7ahpMrn0ZPizcuNBfLqvEr0yE7Do4v5ejxEzefrYV84IYtiltwxUQ2s7Gttsz93c8UV48/tSlJTWY/7L3+O684rw0MyhHj8jr8KL18hlArNVQl2LSX7RBoBDlU1yg+6phlb0SPN8A2q3WPHwhr1ot9jerBUK2/nWNBnx/bFan8+Hoa0dd76xE01GMzIStMhI1CIjQYcWkwWf7quUnwvANnvo5gt7yxPZnR2sbIJVsvVzXdgvC/Wt7WhoMaGsvg01TUZ8cbAaXxysxsMb9kGhgEdAc8P5xfjDzwa7XOa8Ag8Asu2N9kazFXUt7R0GAc9+dgjf2R/78B4pmD4kF9OH5CI/VY/jp1tw/HQzNu2rwvrtJ7HjeJ3P2/nndyfwzo4yAMDf/3cUANA/JxFTB+bgvukDvD4fAHD/Wz/gP7tO+T1HAFArFbh4cG6HxwkigCqrb8WUP38OwLbVjVatdAmaemcmoF9OIr49Wov6lnZs2l+FTfur8MXBarxy/diA70+osJdOve3VN2d8EfZVNKK+xYS2dgta2y1oa7fCZLZi54l67DxRj5e/PgYAeOD/DcTNF3oPxEtKbb+HZT8fjP83LA97TxmwcuNBfHu0FgcqG30GUF8dtgVeH++pCDiA2nPKUQI9ftpLACVW4dn/znJ8jDIwma3yWAl/gfAtk3rD0NaOtnYL2i0SzFYrKg1G7K9oRHlDm/wBIRIwgCIKQEsnm8jNFitufHUbBucl4/4ZAwO+P5GluWVSH4wusu1UXttswv6KRntJomdAt+P8InaosjGgAEqSJGw/bntDPekUGLgrq7ddV+D2gpZmL+HVtpg8MiBldbY3l/QELR78xVDcMbUvnv70EN749gQ+P1jl9X5EAJUar4VWrURGghanm02oajS6BFD7yh3Nwj9VN3sNoI6fbka7RUKCVoX37piIwvR4GNutGPGnT1Ba24qGlnakxHvOGPp4dwW+OFjt87nQqZW4oF8mvjxYg7Z2K8rqWtEzw/P+D9snMI/umYa/XOMoqUqShIOVTfjyYDW+PFSNb4/WwmS2vcmrlAro1Uo0myz43yHPc5ADKHsGSqdWITNRi5omE8obWjsMoEQm0VtWYlBeMgblJaNvdiLWbz+JPacMsFglr8GQc3ahyWjG4aomHKy0fZ3fNxPn98v0+BmrVcLnB2y/96KMeKjttysByErUoX9OEvrlJKJfdhIG5iYFlNESUuI1uPnC3tjwQznqW0xoNllglYC2disyErT4+Yh8XDGqwD5/SAGrVcLecgM27q3EM5sO4dujp9FusQZd0qtosO8Ll+IZQJ3TMw0f3nWBx3NworYFJaX12HmiDt8ercX+ikb8u+SU1wDKYpXkWVIjC9OQpNdgXO8MXNg/C98ercVP1U1ez0uSJBypsl23zU8g7E68FgHA8dOerweiiTwj0fa78VVC3l9hgNFsRUqcBsWZCT7v76JBOR5/h5c+8z/sKzfgx7IGBlBE0UZkoLQqJUwWa8AlvAOVjfj8QDW2/HQa900fEFD6uaqxDdWNRigUtrS14JgjE3hTrHMa/WBlIyb09XwTc/dTdbO8qutkne9GZHFdjzTXFzTxhm0yW9FisiBB53iZKat3/ZnsJD0WTOmLN749gfL6No83Z0mSHCU8++1mJelwutmESkOby6fhvU4B1OGqJkzqn+VxzocqbW8gfbMT0c++b5xeo0JhehxKa1ux51SD1+dIZASnD8nBBf2ycLrJhNPNRpitEi7sl4kL+2chXqvGjKe/xP6KRhysbPQRQNnvP8c1a6dQKDAgNwkDcpNw04W90dZuQUNrO5L0asRpVKhqNGLco5twuKoJrSYL4rSOXpBKeWijI5jMTdGjpsmEioY2r6udhPoWk/w7GdMr3edxxZmJSNCq0Gyy4KfqJnnPPWdivtHvLhuEc3ul43STEfeu34XNB6qx7Xit1wDqSE0TDG1m6DVKfLpo0hn3H7l74P8NkkuORrMF9S22DGhRRrzHfSmVCgwtSMHgvGSs/eYYGlrbseeUIaiyIeD0+/BR+nanVCrQKzMBvTITMHNUASoNbRj36CbsLTfA0Nbu0l8I2P6Gmk0WJGhV6Jvt+DvqbQ9Kfqpu9no/1Y1GuWR9pLoZtc2mgEqUu50yUMfcAihJcuxL6V7Ccx+j4RxgB1uGG1aQbAugTjZg+pDAs5BdjavwiAIgVqBk2j9lBVrCE2/+RrMVhtbAfmav/RNfcWaCS/AxzD4q4EBFo88VMe6c94w7VOX9k6m7bU6lrJN13jNQZotVfoEscAug4jQq6NS2lxb3FUJldZ5Zq5xkPdRKBcxWyWO+U6PRDLO9NybVnhkSPVnuK/H2uQVQ3sgBTLZrACDmBjm/WTgTm8D+fEQ+5pxXhLum9cOffjEUj14xDDOG5iFea/s9icDC13MtLu/rVvZ0p9eokJOsR7xWDYVCgewkHTITdbBKwL4K12X5zlPIhbwURx+UPyLoLEyP8zvdW+W07NzbJO2KhjZUGoxQKhwbymYk6jB1YDYAW7+bNzuO1wNASJq3O6JT257TvtmJfu9LqVRgjD3ru81PWdcXMcDUWwYqEDnJevRMj4ckeX/exDysYT1SXD5s9LEHU0eqm7yucD3slpny9Ttx55yBOlHrGpw1Gs1yOVyU8MTjdi/hddRA7o947QvXYFRfGEARBUDMgcq0l8ACzUA5T+MOdPijeMFyzxzkp+iRkaCF2Sq5BAv+VLiU8AIMoJxeWMsNbXIpyVlloxEWqwSNSuGynxVgy6ak+5hGLrIdzgGUSqmQX3RP1btmvEQfVZxGJa/+yUny3A9Pklyfk586CmCyXQOYofLWH57Pa1u7BfvtQYu/TWwBoJ/9dg/Zm27diQCun5cMjj8KhQJDC2yByR63NxHxRuX8e3AM0/Q/ykAE60PyOu6pG+pnLIDI0PXPSZKDSQAYXWTLau08Ue/SJC7stPfydOZNtSuN7iUCqMBLXYIIaDsbQAHAufZs4PdHPQO4EjF7zS0zVpQRD6UCaGwzo9rLmAT3zFQgAZTIhgvHalw/UInyXYLW8e9TZN7qWtpdPuh11EDuj/PWPJG0jRYDKKIAiB4o0cTcbAouAwUEPrtIflPLd23WVCgU8iapgXwSkyTJ5VPgwarGgF58nD91S5L3N2HRG5WfGue1H8bXSjxR9nPPWom+BveSYZ1b+Q5wNEk7P7YKQ5t8LOD5aVu+XAQwbgGUeK69ZaD2lRvQbpGQnqD1KFe66+cnA9XQ2i7/DYhNV4MhZ8nK3DNQrvuuOf9/RxkoEawPdvtb82a4n7+9H7wMVAWAAblJSNSp0WQ040CFZ1ApMlDn9Ezr8P670xh74LfteF1Qb9iNbe1ydjrQEp43Y4ttz4e3hQ0lPrZC0alV8sq9n6o8y3jiQ4V4DRN9jv6Ivw+RXTrV0Aqj2REUOW/jIqTEaaDX2EIL8bdZ12wbFwJ0LoAamJsEtVKB080mnIqgAbEMoIgCID5JZdlfKJoCbCJ33kYi0A1wxaoX9wAKAIYXBN4H1dDaDqM9e6RU2II5b59MnVU3GnHsdAsUCsjbpnjrg/KWSXImZ6DcS3g+fq6H/fsy9wyU3EDuKC+JUpVzeXKfUykKsJUO3cuHFqskN9i6Z6BEtu9oTbNHeVbeQsTebOxPP3tv0+GqJo9BgCJ4y0vRI0nvfzNcb0QGyjnIazKa0WwP7rOdFgjkpwQ2jdzf35rn/dueo732RnJn4u/ReaAqYMsuiuyS+xu2oa0dB+1N9ZEWQA3vkQKNSoGaJqPLCsuOiH/jSXq1S/k9WCIDtau0wSWL02qyyCMFvE1kF31QR2o8A3jxt3/l6ALbbZ9scAmGvBHZzvP7ZSJeq4Ikub4e1Lg1kAPwOotMZM16ZyZ0ao6YXqOSy+ORtBkzAyiiAIgm8swk2z/+QEt4wWagGtva5UZNb82/ci9AAC8iopSQGq9BUYbthfVwB2U88SY3ICcJA3Ntb6re+qB8NZAL6T72wyuTf861wVpkpMrcM1BO++AJjllQjuBgX7njjVgEZ+59UGV1rTCardCqlR4zdrKSdMhN1kOS4FEe/SGILUSK0uOhVSnR2m7xCAbFCjz34C1Q4u/hYGWj/MYn3qCSdK5v2IFkoNraLXJZx1+judA7MwEJWhVa2y0uK70kSXI8R15KnGIVqfvKr12l9ZAkW9Ab6HiN7qLXqOSyUTBlPHkF3hlknwBb/2NmohYmi9Xlw9LuU7Z5Wdn2v1d3YqSItwzUEfvvetqgHGQkaO1jBfy3AogM1ND8FHlrnOOnHbdd6zZEU5CnkdsDSpE160z2SXBMlq/v9G2EGgMoog5IkuQIoOQMVKA9UE4BVAD7t4lAIC9F73WFjCijHKpqREsHZcQKp9VA4k37oI/eHEG8WYzplSZnc7xloE7KzeDeh/1564FqMZnlkp57Ca/AZwbK9vw5L1/PSvLcD0+UPQfnJcvNtO4B1OFq22PvnZngtewoZ3jcSlQlPspT3qhVSvS2l+fcn+vDPvqvAtUjzdbo3W6R5H62KrcZUIJzD5SvEtT+ikZYrBIyEhybNPujVCowxEsG9PjpFjS0tkOrVmJArmdvlyiHuffcRGr5ThCrErcFUOoSzrSBXFAoFI4+KKcy3q4OVrL1tgdQ7hmoFpNZ/rfVNysR59iD2o7KeHuc2gl62T+EOY8ycMyAcv37cW8k3+lnA+FAOdoXundvQ38YQBF1wGi2ygMN5R6oAAOohlanEl4ATeQdlVRykvXISbatxtp7yv8LidxcnKxHf3tp6WAHK/G+t7/JjSlKl7NEpV5KGO7jCNyJjFFtsyOAFA3iSTq1x4ov0QPl3kRe7zREUxBv9tWNRjk4EFmjQXnJ8go393k4ziMMvPHWSN7Q2i5/chfBa0d89UH5amAPlEKhcGmmBRx/U+4BkMgAtLVb0dDqfU878bc2OD854GXl7vcPOBrIB+cle13dNrJnKpQKWyDuXMbeccL2txapAZScOQsiAxXsCAN/xhbbAqjvnBrJRSDiKxsqeuvc//ZF/1F6ghZpCVqnVYa+H1tDa7tcvhycn4yiTJGBcgqgmj1LeIBrBtRqlZwCv87/riOxkZwBFFEHWp2GaAYbQDlnoKoDyEDtccqk+DKsIBVAx31QcnYiSedYXu8nA9Vqssg9D2N6pcnBkfcMVEclPM/98Hw1kDtfVlbnmjGR98GLd85A2X4HJostOGgxmXHUXlYQQx8BLxkouYHc+wo40aTtPHlZBAqF6XEujbL+9POR7evo/gMxxJ4lE43comSU47YSUq9RORp/670H7r5We/ozTM5A1cuXiREPI3wEmIk6tVwOFm/YVquEnVESQB2qanLpZfSnwktDf2eJDNSO43Vyz5kIRNwbyAWRfT1Z1+rSOyVKtaJHaox9leGOE76b5MUHtILUOKTGa1GULjJQjhKe+zYuQq7TNPKjp5vR0NoOnVqJgQFuBO3NAHsjeW2zySNTHS4MoIg64DxEU2ROOtNEHsgYA8eqKN9vav5WQzlzfjF3lPC8z4gBbMuMzVYJucl6FKTGyRko9wDKapXkTJG3YAhwlNxqnR6/v6yVKOE1mywuGRPHPniODJROrZKbysUWD5JkC6yyknS+AygfDeSCyEAdqmqS33zE0uvhAZTvhP45nvfvUkLpZAYKcJ5XZfs7cd/GxZljTzLvbza+Vnv6I8ooe8sNMFtsCxREMOXvORotl4xsQZPzAM0zeVPtSpmJOjngENmyjoieNG/74AVrUF4yknRqNBrN2FduQE2TESfrWqFQOH4P7jIStEjWqyFJwDGnQEeswBM9UkPyU6BVKVHTZPI6XRzwzIb3yvCSgXLbxkVwbiIX/U/DClLOaNaXXqOSS8TuZfZwYQBF1AERQOk1SiTaG3U700ReaTD6TT0bzRY5Q+TvTW1YD88sgDeiRyg7WY8+WYlQKmxpeV8r8cT4gjG90qBQKORAp7KxzWW1TlWjEe0W28RwX6WK9HjPJnI5A+Vl5Z5eo5KHlDoHbPI+eO5NqklimGabS/kOcAQoZfWtcp+YJElyA72vACYnWYfMRC0sVgn77Uvu5dJDEAGUXMKrdKzEO1LdDEmyvdF0ZoNaQQR5ttEKVjkoz/HShJ3np5Hc9hiDD6CKMxKQqFOjrd2Kn6qbYbZY5VWB/prsRcZD9Nx05wDNMxFsGU98aMkLQQZKpVTIvUrfH6uV/xb7ZiX6XMWpUCjkLJRzI7ko6fXJtgWEeo1Kfh3xta2LCLDF35yYrF9a1yJnxNy3cRFEQF/R0CbP+jqTBnJhmJ9ZZOEQuX+5RBFClPDitCok6GzD4lrbLV4HAzqTJAn1TtmU1naL3+bzQ5VNMFslpMRp/M4bEi8iR2qa0djmvb8FcO3H0GtU8ko8XwM1t8n9T7YX7YwELeI0tqXL5U5lILEHXl6KHmofb37piZ5jDMr8lPAA743k3kp4gGMWVJXBKAdQouyZ7hSkiP6lKvs2FiqlAr0yvTe+KxSOadviE24wK/AEbyvxRDaqzxlkn8RtJ+rUMJmt+Km6yW/GQ55G7qWEd6S6CW3tViRoVXJzcCCUSoU8M+qHk/X2bJ0VSTq1nK3xRgQie04Z0GqyRHz/kzAmyIGackk1BBkowLUPalcH/U9C70zHRHJBlPCcN/4e00Ej+R63DGVeShy0KiXaLY4MtLyNi1sTuQggqxqNcrA8KgS/62Gd2M6qKzGAIuqAyEDFaVQuS8U7GqbZaDTLQZbWvrWJv1EGzivJ/DX1ZibqUJAaB0ly3WbBnVzesQcbvnpzAFtGYocIoOy9F85ZqFKnUQb+MkmCyEDVtZjkLIxjBpT3AMZbI7mjhOcaQIk+qMrGNvl5G+RUChLNtCJwEUFjUXo8dGoVfJGnfZ9qQKWhDRWGNigVjssD4bwS75B9dIH4r/sAz2A5BzC7ywyObVz8lPC8ZaD2nHJk7ZReViT6M9ypmVe8qQ8tSPF7OwWpcchJ1sFslbDrZL1TAJUa1H13NzFJfdfJeq8T+Z2ZzFbUNJ35FHJnzivxdgY4yVtkmUTWyWqV5GDKOYDyl11ra7fIJW/xoUKlVMgrc4+fboHVKskfcDLdMlBZiTooFYDZvkEzYFtMcKYirZGcARRRBxwZKDV0aqW8Y3xHZbwG+5u/Tq10lMP8DNMMZqiht2ZeZ2aLVd6CQZTZxJDHg14yUAcrG9FoNNsbfh2BiLdG8pM+Zjk5Exkjq2QbmAg4z4DqIANlP06SJLmHynmQJuD4hF/Z0CaX25wb7937oAKdweQ87VsEB+7bkwSir7yli7j/M1uB5/0cGxwlPK8ZKN89UM4r8IIlZwHKGrDLxwBNdwqFQh5nsPlAlbwiUZSoIlWfrASkxWtgNFt97pMoiN+FVqX0CPg7a3gPR6/Slp9OA+g4gBIZKJF1Kqu3zz9TKV3+7Tk3yTe0uGayfY24EFns47XNqG9th0jCu5fY1SqlvOAGsM1uyw9BUDkgNwkalQJ1Le0R0UjOAIqoA44MlBIKhULOQnUUQMn9O/FaefhjtZ8MlJwyDyDb0VEq+3SzCVbJNoFcrJARK/FEMOFM9D+N6pnqUpZzNJJ7yUD5KTNq1Uok2Z+n2mYTTGarvOTeZwkvzbWE19pukT/1u/cNiefz+2N1aDFZoFMrUexUQurjNsqgowZyQfR7HKholEuagcx/cieeaxGsnukIA9dztP19fHmoWt7INcvLCkF/Gwq7l2eCMcypD0uspAvkORJv2P/89gQkCeiZHu/yJhuJFAqFnIXa3kEZzzE2RBd0Vs8XvUaFEfbg1GyVoPMxa8tZX3sGSmwqLP4N9MqMd/m3neGnSV7+MFfgOn2/yKmRXDSQp8RpvPaxOfeB+ZpbFSyd2tFIHgkTyRlAEXVArMiK09pKP6KRvKOVeKL8lBqv8br9iDOr0wbBgSwr72glnngxz0rSyUMjxfJ5byvxtjnNf3LmPQPV4nKdL2lOwzRtAx1tjfjuK3YE9x4oMQJCq1IiXutadhPPpygPDMhNcnlzcM9AiUyQyML50iMtDsl6NUwWK97dWQag4+yKN/3k+2+EyWyVVy6dyQgDQQR5or8rM1Erl4idyU3k9W0uv29Jkjo1wkDo5dRILrJ/gczIEgGUoc32wSPSNhD2RfRBeduXzpkIVEMxA8qZKOMBtt99R033PdNtg2KbTRZUGoxe+58Ex5R418fmK8AW/XLHapq9buPizDkrGor+JyGSGsljJoA6duwYbrjhBhQXFyMuLg59+vTBsmXLYDKZXI5RKBQeX1u3bnW5rfXr12PgwIHQ6/UYNmwYPvjgg+5+OBRB5BKefbdx0UgeaAYqNV4jZ0x8lfCOnW5Gsz2T4q8ZVxhunwV1/HSLR/odcCyndn4x752V4FiJ55YJc55A7kxseeIcQHU0RFMQAdTpJpNclstPjfP5STTfrYRX1+x4/tx/Jttt1dmgXNcXehFAHTttWykm74GX5T+AUSgUcoAinqPOZKCch2kerWmGxSohUacOaOJ3R3pnJsibtQJAdpL3N2zRh9PaboGh1fG3WlbfiobWdqiVig4DSm+USoXLG2tmotZvP5wwOD9Z/jcERH4DuTDGaQSDv74b+d9ciPqfhHOLHQFUICvZtGqlvO3Kkeomxwo8fwGUW3ZNzINzD6DESrwTtS2O/qcE73/TuW4ZqFARc/AYQIXQ/v37YbVa8be//Q179uzBU089hdWrV+OBBx7wOPbTTz9FeXm5/DV69Gj5um+++QbXXHMNbrjhBuzcuRMzZ87EzJkzsXv37u58OBRBWkxijIEIoEQGqoMeKPsKvNQ4rfwm56uJXHziG+iWSfElJV4jp9O9vZBUNjpGGAjOK/Gc+6B2lzWgrL4VKqXC44VObiK3TySWJMnRy+SjGVzIcMpABdJ4Lu7rdLMJbe0WOQD1tuzfPWhw7+XJT4lDnEaFdoutaVl8WhYNtv6IAApAQCUTb4oy4qFRKdBisuDLg9UAbEFdKMoYapVSHtkAeE4hF/QalTzBvdypD0r8rfXLSfLbUO+Pc8ZpeI/AyjMalVIuRwHRE0ANLbD1IZ1uNuHPnxzAhh/Ksa/ctpqwyWjGocpGfHGwWu5RCnUGanRRGsTTG+hqUOeJ5PIMKC9/+yI4+/ZoLe5bvwsNLe0wWxyZRfcMpfN2LqJh3tdYDpGBUioCn+IfCOcMVLgbyTu/XXSEmTFjBmbMmCF/37t3bxw4cADPP/88/vznP7scm5GRgdzcXK+388wzz2DGjBm47777AAAPPfQQNm7ciOeeew6rV6/uugdAEUv0QMW7lfA6zEA1i33cNI5l9z6GaQYyQNPdsIIUHD/dgh/K6nF+v0yX6yp9lBP6ZSfiaE0zDlY24vx+mWgxmXHXmzsBANOH5HjsIC96oKoajWhrt8DQ1g6j2QqlouNP2s7buYjn0F/jeUqcBglaFZpNtuX/dU4lUHfZbkHDILfJ7UqlAn2yE7C7zICP91QCsAVvgTSDO3/qHpLvfXuSjmhUSvTOTMSBykZ8sLscQGj6n4Sh+SnYaR9Q6O/3kJcSh7qWdnz4YwUG5CRBoVB0aoCmx/0XOAdQgf/Nji5Kw9YjtRE9QNOdXqPC6KI0bDlyGqs2/9Th8R1lZoOVrNfg/w3Nw3fHanF+38yOfwD2PfH2VeGn6ma/Jbw+WYlYMKUvVn1+GOu3n8TnB6tx/cRiGM1WJOrUKHLbdLsgNQ5Khe01UcwR81XCy0+1/V32z0nyeF05E/1zE6FVKVHf0o6Tda0eG4N3p5jJQHnT0NCA9PR0j8svv/xyZGdn4/zzz8d//vMfl+u2bNmCadOmuVw2ffp0bNmypUvPlSJXW7tbCU8bWABVb98HL8U5A+WjByqYFXiCeOP6odRLBspthIHQ322ftofe34ufqpuRk6zDwzOHedxOWrxGDhxP1bfK2aecZL3Xvhtn8nYuLaYOV+ABtvKZ85YuooSX5mVFk16jQrLe8aLs7c1Y7In3YZABjHNwEMz8J4/7t5fHRKBzpiMMnA1zOkdfJTwAmDYoGwDwzKZDmL/2e1Q1tp1RA7m3+w+mxDllgO18LuiXFdEDNN39+VcjcN/0AbjynB4Y1TPVZS/HJL0aA3KSMGVAFm48vxhXnNMj5Pe/6tpz8P3vpgU8hFVkoHaeqJMzRb29BFAAcO/0AVh/y3j0zkxAdaMRj3+0H4BtVat7M7xWrZT/jYr5Tr62OLpoUA5+OaoAv50xMKBzDpRLI3mYy3gxk4Fyd/jwYTz77LMu2afExESsWLECEydOhFKpxNtvv42ZM2fivffew+WXXw4AqKioQE5Ojstt5eTkoKKiwud9GY1GGI2ON0aDIXJ2i6YzJ3qg9Fr3El5gTeRp8c4ZKM8ASpKkTmUFxNYZu7yMMqiQAyi3DFSOWF7fiA9+LMc/vyuFQgE89auRXl+cxSyog5VNOFnXKpclA/mULW/n0mySh2921CuTn2q7L1sGyvsUciE7WQ9DWxMK0+OQ7GUyswiYSmttwVugAUxxRoKcCetM/5PQPzsJG1DucT6h4LxS018G6u5p/ZGeoMWjH+7H5weqMePp/8lbsHSmgVzolZGAXhnxqGtpD6oZfEyvdGz4v/M7LP9GmoLUONwxpa/8vSRJqG9ph0bt2J0gkohgSYyZyE3W+z3PMb3S8cFdF+DpTw/h7/87AotVcvkg4axXRgJKa1tx0L6a130GlJCs12Dl7JFn8Ch8G1qQgh/LGvBjWQP+37C8LrmPQETeb97N4sWL8fjjj/s9Zt++fRg40BHllpWVYcaMGZg1axZuuukm+fLMzEwsWrRI/v7cc8/FqVOn8OSTT8oBVGcsX74cDz74YKd/niJbi1sGKjHAJvJ6pzEGIpBpMprRbDS7pLSrGo043WyCUgF509VADCtIgVJhW/1TaWhzCZZEpssjgLKvAttXbsDit38AANw2qQ8m+CkNFKbFywGUmOnkrxQnyMM0m00BjT4AXGdBiR6zNC8lPMCWXTtc1eTRQC64ByyBBjBKpQLXje+FLw5WY/KArIB+xhv3Bu1QrMBzvi2tSgmTxeq3MV2pVGDexGJM6JuJu94skVd6Aq6DR4OlVCrw1m0T0G6xekyJ78iZBG6RQqFQ+AzsI4F7uS6Q3j+9RoXFlw7EZcPy8J9dZZg/sdjrcaJBXbQfncnWRJ01qX8mjO2WkDand0bEB1D33HMP5s2b5/eY3r17y/9/6tQpTJkyBRMmTMALL7zQ4e2PGzcOGzdulL/Pzc1FZWWlyzGVlZU+e6YAYMmSJS6BmcFgQGFhYYf3TdGhzeTaAxVoE7no4UmJ1yBRp0a8VoUWkwVVjUYUOwVQYil+cWaCPCohEAk6NfrnJGF/RSN2nqjHjKGOv9FKHwMWxUq8ZvtjGlmYioUX9/d7P87TyMXWMYGsuhJvMDVNRnmFUkeZKxFgnapvhdk+pc9bCQ+wNYoDvt+Q3d9EgskALb50IBZfemalh/5OAZTOqfQRClq1EpMHZOHrwzXyYE3/55KE9+6YgJUbD+KFL49gWEGKz/3UAhXpM5zOZukJWqTGa+QsuLf+J1+G9UjxuVkxAI+tf9y3cekOM4bmYcbQ8GWehIgPoLKyspCVFdinwLKyMkyZMgWjR4/Gyy+/DKWy4xp7SUkJ8vIcv4jx48dj06ZNuPvuu+XLNm7ciPHjx/u8DZ1OB52OLyaxqtW9ByrIVXgiAMhJ1uNoTTOqDG0uQx/dN8MNxqieqdhf0YiSUkcA1dZukV843ZvI9Rrb3mdHapqRqFPjL1eP6rAXxTFMs1UOoAIp4YlVeAfte/yplQq//TqAIzA7Wd8Knb3HylcAdcukPkiN12DOeT29Xl+UYZuHI7bTCWUJLRBFGQnQqBRot0jok5Uoz+MKldVzRqPNbAl4SrpOrcKSSwfh2rFFSE04s+CJIl+frERst893CyaA6ogYZSD4KuGdDSI+gApUWVkZJk+ejKKiIvz5z39GdXW1fJ3IHr3yyivQarUYNWoUAOCdd97BmjVr8OKLL8rH3nXXXZg0aRJWrFiByy67DG+++Sa2bdsWUDaLYpMIoPSaIFfhuW1DkpWkswVQbn1Q+8ptvQSdCaBG9EjFP78rlbcdARzlO51aieQ4z3/iF/TLxPHaFjz6y2EeL4beOIZptqDJPgQxkGyKyECJ5y8vVd9hEOFcwhOlgTQfb/Z9sxPxu8sG+7wtrVqJoox4HKluRmaiLuhS05nSqGzT0Q9WNnVJ8KZUKoLeYgbwfAOk2NQnK6FLAiiPDNRZnImMmQBq48aNOHz4MA4fPowePVxXQTjPinjooYdw/PhxqNVqDBw4EOvWrcNVV10lXz9hwgS88cYb+P3vf48HHngA/fr1w3vvvYehQ4d222OhyNJicp1EHkgGymqVHHOg7AGUr2GaIgM1uBMBlNig84eT9bBYJaiUCrmBPDdF73U+z9KfD8GdF/ULuAQjlgmX1rbKQWMwPVBCIGU/EZhVGNpgtf+7PZPAp29WIo5UN4d0BVww+uck4WBlU6dmSRGdCedVd4H0QAWqp9PYAKUCSI07e7OZMRNAzZs3r8Neqblz52Lu3Lkd3tasWbMwa9asEJ0ZRbu2TsyBMrS1y02WqXGOEh7guh9eW7tF3im9MxmoftlJ8oqxw1W2N2p5hIGPcplKqQiqf0VkoMRyaMAx48Wf5DgNlArIG44GEnRlJ+mhVipgtkry1hhnsjHr4PxkfLK3slPPbSj830X9kJWkw+xz2RNJ3UtkneK1qpAO94zTqpCTrEOlwYj0BG3I9v2LRtEziIMoTFpNvkp4vscYiB6kBK1KnpckMlDOJbyDlY2wSraVZp3Z5kOlVMgNnyWltnS986amoZASp3FZAp2dpAtogrVKqXDJHgWSgVIpFchzC8589UAFYv6EYiz92WDcNrlPp2/jTPTPScKynw9hwzV1u3N7pSE/RY/LR+SHZAK+M7GjQTgayCMJAyiiDng2kdv+66+E5+h/crz5i4DGuYTn3EDe2Re5kYW2LTFK7AM1xe2H6lOnmAUlBDNp2XkEQaCr0JwDLZVSgSR95xPlKfEaXH9+MbKSzu4Xejr7pMZr8fXiqXjsyuEhv20xodzXFPKzBQMoog7Ik8jdS3gm3wFUfavnNiQ5XvbDO5MGcmFkochA1QMAKn3MgDoTzkFTQQClOMF5RkyPADJQgGNTYcDWX3E2lwiIzkSoM09CsX3S+dn+wSRmeqCIuorcRO42xsBfD1S92wo8wJGBqnLKQO09gxEGgshAHagwoMVkdkwhD+Gu8M79S8FkoJwDqEAzUM6Blrd98IgovGaNLkRZXSt+Pc77CJGzBQMoIj8kSXKU8NxW4bVbJBjNFq/9QPXyRriOACLLnoEytJnR1m6BTq10KuF1fpVWbooeucl6VBja8OPJBjlAywnhp8POlvBEAKVQ2Da2DYRzoBWOKcdE5F9Wkg6PXOG5d+bZhiU8Ij+MZqu8ms6xmbAjYPLVSC6mkDsv8U3Wq6HX2P7JVRmMKKtvRWObGWql4oznBIktDUpK613GGISKcwYqkGZwQR4imtTx5sOO23fcV3fPbiIiChQDKCI/RP8T4FiFp1Yp5UDIVxmvwWkfPEGhcEzirmpsk/uf+mYnBrSqzZ8R9gDqf4dq0NZu2yy2o6nfwXDNQAXfAxXMNibOIxJ87YNHRBRuDKCI/BD9TxqVwmXLk8QOhmnKGSi3AMAxTNN4Rlu4uBMZqK1HTgOwZbuC2VevIz0z4qFWKqBVK4PKQI3qmQaNSoEL+vnerNidcxN5JG/YSkRnN/ZAEfnhPsJASNCpUdNk8pmBcqzCcw0AxMo4WwbqzPufhOE9UqBUQN6AN5TlOwBI1mvw12vPgVqlCCowG12Uhh+WTQ/qZ/QaFTITdahpMp7RDCgioq7EAIrIj1a3bVyEBK3/DJS8Cs9tm4Msp2GaocxAJejU6J+ThP0VtrJgKEcYCJcMye3Uz3UmE1aQFmcPoFjCI6LIxBIekR9tPjJQHU0jF6vw3DfCFaMMjlY343htC4DQBFCAo4wHdE0A1Z2uObcQg/OScX6/rHCfChGRVwygiPwQJTy9RwnP9r2vEp6YRJ4S51bCszd2f/NTDSTJlpEK1TYfI1wCqOgecHf12J744K4Lguq3IiLqTgygiPwQTeTx7iU8P03kZosVjW22y91LUCIDZbBfH8pNbp0zUKHcPJSIiDwxgCLyw30bFyHRzzTyBnsDOWDbiNeZ+2iBUDSQC/1zkuRAL5sBFBFRl2IAReRHq8n3KjwAaPKyH55YgZekV0Otcv0n5l5aGxzCDJRKqcDMUQXISNBiVM/UkN0uERF54io8Ij9890D5zkB52wdPSInTQKtWwmS2DbsMZQkPAB69Yhge/sVQbsBLRNTFmIEi8sNXD1Si3ETuuQpPXoHnZYaRQqFAlr1pXKtWondmQkjPFwCDJyKibsAAisgPX2MM/DWRiynk7v1Pgijj9c9J9CjxERFRdOCrN511moxmvLb1OGqajB0eK3qg9EE0kdd72QfPmWgkH5Qb2vIdERF1HwZQdNb557cn8Pv3duOZTw91eKzPrVy0/gIoUcLznoESDd4X9OeQSCKiaMUmcjrrlNbZJoDvLK3r8Fh/e+EB3kt49a32IZo+MlA3X9gbM0cVRP20cCKisxkzUHTWqW60le4OVjSh3WL1e2yrzyZy31u51HWQgVIoFAyeiIiiHAMoOuuIAMpkseJQZZPfYzuzlUuDPYDyNsaAiIhiAwMoOus4N4/vPtXg91h5kKavDJTJDEmSXK6rk+dAeS/hERFR9GMARWcdkYECgL2nDH6P7WiMgVVyZKkE0USe6mOMARERRT8GUHRWaTGZ0WxyBDx7OshAtfjIQMVrVVDY51W6N5J3NMaAiIiiHwMoOqvUNJpcvt97ygCrVfJxtO9VeAqFwmmUgSMgM5mtcoDGHigiotjFAIrOKtX2/qf8FD10aiWaTRYcO93s83i5hOeWgQIcjeRNbY4MlBhhoFAAyXoGUEREsYoBFJ1VRP9TTope3sh3j58+KLmJXOMtgPKcBdXgtI0L96QjIopdDKDorCIyUJmJOgzJtwVQvlbiSZKEFj8ZKG/budT52UiYiIhiBwMoOqvU2DNQWUk6DMlPAeB7JZ7RbIWYUOA1A6V1jDIQRAO5r42EiYgoNjCAorOKyEBlJeowtMBRwnOf5QQ4+p8Az0GagPcSXkf74BERUWxgAEVnFZGBykzSoX9OElRKBWqbTShvaPM4VqzA06gU0Kg8/6kkeplGLprIOUSTiCi2MYCis4pzBkqvUaFfdiIA743kooHcW/YJcM5AOTJVddzGhYjorBBTAVSvXr2gUChcvh577DGXY3744QdccMEF0Ov1KCwsxBNPPOFxO+vXr8fAgQOh1+sxbNgwfPDBB931EKiLiW1cspJsGSLRB+VtoGaLj42EBW9N5I4p5MxAERHFspgKoADgT3/6E8rLy+WvO++8U77OYDDgkksuQVFREbZv344nn3wSf/zjH/HCCy/Ix3zzzTe45pprcMMNN2Dnzp2YOXMmZs6cid27d4fj4VAISZIkjzHIStQDgGMlXplnBsrXNi5CglsAZbFKOFJt25w4LYEZKCKiWKYO9wmEWlJSEnJzc71e9/rrr8NkMmHNmjXQarUYMmQISkpKsHLlStx8880AgGeeeQYzZszAfffdBwB46KGHsHHjRjz33HNYvXp1tz0OCr0moxlt7VYAQKacgbIFUHu9ZKBED1THJTwzaptN+L9/7sS3R2sBAMN7pIb03ImIKLLEXAbqscceQ0ZGBkaNGoUnn3wSZrOjvLJlyxZceOGF0God5ZXp06fjwIEDqKurk4+ZNm2ay21Onz4dW7Zs8XmfRqMRBoPB5YsiT02TrcE7QatCvH0EwWB7AHWqoQ21za7bvLT62AdPEE3kByoa8fNnv8JXh2sQr1Xh2WtGYWRhalc8BCIiihAxlYH6v//7P5xzzjlIT0/HN998gyVLlqC8vBwrV64EAFRUVKC4uNjlZ3JycuTr0tLSUFFRIV/mfExFRYXP+12+fDkefPDBED8aCrVqpxlQQpJeg14Z8Th2ugV7TjXggn5Z8nUiA+WrB0pkoA5V2cp2xZkJWD1nNAbkJnXJ+RMRUeSI+AzU4sWLPRrD3b/2798PAFi0aBEmT56M4cOH49Zbb8WKFSvw7LPPwmg0duk5LlmyBA0NDfJXaWlpl94fdU6N0xRyZ45GctfMob9tXADXve6mDcrBvxdMZPBERHSWiPgM1D333IN58+b5PaZ3795eLx83bhzMZjOOHTuGAQMGIDc3F5WVlS7HiO9F35SvY3z1VQGATqeDTqfzeT1FBm8ZKMBWxtvwY7lnANVBD9TY4nRcMaoAQ/KTcf3EYu59R0R0Fon4ACorKwtZWVkdH+hFSUkJlEolsrOzAQDjx4/H7373O7S3t0OjsWUPNm7ciAEDBiAtLU0+ZtOmTbj77rvl29m4cSPGjx9/Zg+Ews5XBmpogT0DVebaSN7awSo8vUaFp2aPDPFZEhFRNIj4El6gtmzZgqeffhq7du3CkSNH8Prrr2PhwoWYM2eOHBz9+te/hlarxQ033IA9e/Zg3bp1eOaZZ7Bo0SL5du666y589NFHWLFiBfbv348//vGP2LZtGxYsWBCuh0Yh4isDJVbiHT3d7LItS1sHc6CIiOjsFTMBlE6nw5tvvolJkyZhyJAheOSRR7Bw4UKXGU8pKSn45JNPcPToUYwePRr33HMPli5dKo8wAIAJEybgjTfewAsvvIARI0bgrbfewnvvvYehQ4eG42FRCPnKQGUm6pCbrIckAbudslBikKaeARQREbmJ+BJeoM455xxs3bq1w+OGDx+O//3vf36PmTVrFmbNmhWqU6MI4SsDBQAjC1Px0Z4KlJTW47zeGQA6LuEREdHZK2YyUEQdEQFUZqLnNiujeqYCAEpO1MuXMYAiIiJfGEDRWUGSJHmQpq8MFADsLK2TL5O3cmEJj4iI3DCAorOCodUMk8W+jUuiZwA1rEcKVEoFKg1GlDe0AnD0QDEDRURE7hhA0Vmh2t5AnqRXe53rFK9VY0CObQjmTnsZr6OtXIiI6OzFAIrOCv4ayIWRog+qtB6AUwmPGSgiInLDAIrOCr5GGDgbZe+DEo3kbCInIiJfGEDRWSGQDJRYifdDWT3aLVZHAMUSHhERuWEARWcF0QOV5ScD1TszEUl6NdrarThQ0cgeKCIi8okBFJ0VagLIQCmVCqdxBvWOAIolPCIicsMAis4KgWSgANc+KPZAERGRLwygKKp9urcSP55s6PA4uYk8yXMKuTOxEu+7Y6dhlWyXsYRHRETuGEBR1KpoaMONr27DDa983+GxchN5ot7vcSN6pAIASmtb5cu8zY0iIqKzGwMoiloiq1TVaERDS7vP46xWCaft27h0lIHKSNShKCNe/l6jUkCj4j8TIiJyxXcGilrNRrP8/6V1LT6Pq29th9lej8tI8N8DBTj2xQOYfSIiIu8YQFHUEnvVAcCJWt8BlCjfpcZroFV3/Cc/yimAYgM5ERF5wwCKolazySkD5SeAqglwBZ4wsmea/P/xbCAnIiIvGEBR1GoxBpeB8reNi7PBeclypoolPCIi8oYBFEWtFucMVF2rz+PkDJSfIZrOtGolhuQnA+AIAyIi8o4BFEWtZqceKH8lvED2wXMnGsnZA0VERN4wgKKo5ZyBOlnXAouYfOlGTCEPtIQHAJP6ZwEAijISzuAMiYgoVqnDfQJEndXs1APVbpFQaWhDfmqcx3GdyUBNHpCNj+6+AMWZDKCIiMgTM1AUtZwzUIDvRvIaMUQz0f8QTXcDc5OhU7OER0REnhhAUdRy7oECfPdBdSYDRURE5A8DKIpaLfZJ5Dr7yAFvAZTFKqG2Obg5UERERB1hAEVRS0wi75eTCMD7KIOjNU2wSoBeo0QGAygiIgoRBlAUtUQANTDXNrPJWw/UDycbAABD81OgUiq67+SIiCimMYCiqCW2chmYmwTAfwA1rEdK950YERHFPAZQFLXEVi4iA1XdaESrW2P5DyfrAQAjeqR256kREVGMYwBFUUtkoHJT9EjS20aanaxzZKHMFiv2nDIAYAaKiIhCiwEURSVJkuQeqESdGoVp8QCAUqcA6mBlE4xmK5J0ahRzojgREYUQAyiKSiaLVd66JV6nQs90WwB14rQjgPqxrB4AMLQgBUo2kBMRUQgxgKKo1OK0jUu8RoXCdNsWLs6jDEQD+XCW74iIKMQYQFFUEv1POrUSapXSkYFyWonnCKBSu/38iIgotjGAoqgk+p8SdLbm8R72AEpMIzeaLdhfYWsgZwaKiIhCLWYCqM8//xwKhcLr1/fffw8AOHbsmNfrt27d6nJb69evx8CBA6HX6zFs2DB88MEH4XhI5EezfRuXOI1ts9+eTgGUJEnYX96IdouEtHgNeqTFhe08iYgoNsVMADVhwgSUl5e7fN14440oLi7GmDFjXI799NNPXY4bPXq0fN0333yDa665BjfccAN27tyJmTNnYubMmdi9e3d3PyTyw5GBsgVQBalxUChsGwzXNpvwQ5kYoJkKhYIN5EREFFrqcJ9AqGi1WuTm5srft7e349///jfuvPNOjzfQjIwMl2OdPfPMM5gxYwbuu+8+AMBDDz2EjRs34rnnnsPq1au77gFQUEQAFa+1/QnrNSrkJOlRYWhDaV0rfrQP0BxewPIdERGFXsxkoNz95z//wenTpzF//nyP6y6//HJkZ2fj/PPPx3/+8x+X67Zs2YJp06a5XDZ9+nRs2bLF530ZjUYYDAaXL+paLfYmcpGBAuDSSM4VeERE1JViNoB66aWXMH36dPTo0UO+LDExEStWrMD69euxYcMGnH/++Zg5c6ZLEFVRUYGcnByX28rJyUFFRYXP+1q+fDlSUlLkr8LCwtA/IHLRbHTNQAFAD/sog0OVjThY2QiAK/CIiKhrRHwAtXjxYp/N4eJr//79Lj9z8uRJfPzxx7jhhhtcLs/MzMSiRYswbtw4nHvuuXjssccwZ84cPPnkk2d0jkuWLEFDQ4P8VVpaeka3Rx2TM1BazwzUR7srYJWA7CQdclP0YTk/IiKKbRHfA3XPPfdg3rx5fo/p3bu3y/cvv/wyMjIycPnll3d4++PGjcPGjRvl73Nzc1FZWelyTGVlpc+eKQDQ6XTQ6XQd3heFjshAxTlloMR2LoeqmgCwfEdERF0n4gOorKwsZGVlBXy8JEl4+eWX8Zvf/AYajabD40tKSpCXlyd/P378eGzatAl33323fNnGjRsxfvz4oM6bupbXDFRGvMsxwwpSu/OUiIjoLBLxAVSwPvvsMxw9ehQ33nijx3WvvPIKtFotRo0aBQB45513sGbNGrz44ovyMXfddRcmTZqEFStW4LLLLsObb76Jbdu24YUXXui2x0AdE5PI43WeGShheCEzUERE1DViLoB66aWXMGHCBAwcONDr9Q899BCOHz8OtVqNgQMHYt26dbjqqqvk6ydMmIA33ngDv//97/HAAw+gX79+eO+99zB06NDueggUAHkOlFMGKjtJB61aCZPZCoAjDIiIqOvEXAD1xhtv+Lxu7ty5mDt3boe3MWvWLMyaNSuUp0UhJjYTds5AKZUKFKbF4afqZhSkxiEjkX1pRETUNSJ+FR6RN81eeqAAoNC+Eo8N5ERE1JUYQFFUcp9ELgzNtwVO4/tkdPs5ERHR2SPmSnh0dhCbCce7ZaAWTO2LC/plYnRRWjhOi4iIzhIMoCgquW8mLOg1KozrzewTERF1rU6V8FpbW9HS0iJ/f/z4cTz99NP45JNPQnZiRP74KuERERF1h04FUL/4xS/w6quvAgDq6+sxbtw4rFixAr/4xS/w/PPPh/QEibxxDNJkAEVERN2vUwHUjh07cMEFFwAA3nrrLeTk5OD48eN49dVX8Ze//CWkJ0jkzmqVHBkotxIeERFRd+hUANXS0oKkpCQAwCeffIJf/vKXUCqVOO+883D8+PGQniCRu9Z2i/z/zEAREVE4dCqA6tu3L9577z2Ulpbi448/xiWXXAIAqKqqQnJyckhPkMidmAGlUAB6DSdxEBFR9+vUu8/SpUtx7733olevXhg3bpy80e4nn3wi7zNH1FXkKeQaFRQKRZjPhoiIzkadqn9cddVVOP/881FeXo4RI0bIl1900UW44oorQnZyRN44+p9YviMiovDo9DtQbm4ucnNzXS4bO3bsGZ8Qdb1moxkPb9iLiX0z8bPh+eE+naC1+NjGhYiIqLt0KoBqbm7GY489hk2bNqGqqgpWq9Xl+iNHjoTk5Khr/O3LI/jnd6XYfrwuKgOoZs6AIiKiMOvUO9CNN96IL774Atdddx3y8vLYhxJFaptNeOl/tgBXlMKiTYt9Gxf3KeRERETdpVMB1IcffogNGzZg4sSJoT4f6mLPf35YzuAYzdYOjo5MzEAREVG4dWoVXlpaGtLT00N9LtTFKhra8OoWx5wuY3uUZqBM3jcSJiIi6i6dCqAeeughLF261GU/PIp8z352CEazFUUZ8QCAtmjNQBmZgSIiovDq1DvQihUr8NNPPyEnJwe9evWCRqNxuX7Hjh0hOTkKnROnW7Du+1IAwG9nDMTtr++AyWyFJElR18PWamIPFBERhVenAqiZM2eG+DSoqz296SDMVgkX9MvEhf2z5MuNZiv0mugKRNgDRURE4Rb0O5DZbIZCocD111+PHj16dMU5UYgdqmzEuzvLAAD3TR8AndpRuY3GAIpzoIiIKNyC7oFSq9V48sknYTabu+J8qAs8t/kwJAmYPiQHw3ukQq1UQGmv2kVjI7ncA8VJ5EREFCadaiKfOnUqvvjii1CfC3WR3WUNAIBrxxUBABQKBXRqW/YmGkcZcBUeERGFW6c+wl966aVYvHgxfvzxR4wePRoJCQku119++eUhOTkKjcY2W8CRnqCVL9NrlGhtt8BojuIMFAMoIiIKk04FULfffjsAYOXKlR7XKRQKWCzR96Ycy5rsk7uT9I5fty0D1Y629ijMQNnLjglsIiciojDp1DuQ+953FLnMFqu8ZUuiU8+QTmOr3kZjBkps5RLPMQZERBQmneqBoughsk8AkKR3zOsSK/GM0ZiBMjEDRURE4dWpd6A//elPfq9funRpp06GQk/0P+nUSmidxheI0QXR2ETezEGaREQUZp0KoN59912X79vb23H06FGo1Wr06dOHAVQEEQGUc/8T4JSBiuAS3vfHalGUHo/sZL3L5S3cyoWIiMKsU+9AO3fu9LjMYDBg3rx5uOKKK874pCh0GtvaAbiW7wDIYwwitYl8d1kDZq3egnHF6Vh3y3j58naLFSaL7Zy5Co+IiMIlZD1QycnJePDBB/GHP/whVDdJIeBtBR4Q+RmoPadss6v2lRtcLhf9TwAzUEREFD4hbSJvaGhAQ0NDKG+SzpAo4SW6Te12rMKLzAzUsdMtAABDmxkNre3y5WKIpkalcOnpIiIi6k6d+gj/l7/8xeV7SZJQXl6Of/zjH7j00ktDcmIUGo4SnuuvWi8mkUdoCe+EPYACgLK6VqTE2UqQzex/IiKiCNCpd6GnnnrK5XulUomsrCzMnTsXS5YsCcmJUWg0yiU8tx4oewaqLUL3wjt2uln+/5N1LRicnwyAGwkTEVFk6FQN5OjRoy5fP/30E7Zu3YpHH30USUlJoT5HAMAjjzyCCRMmID4+HqmpqV6POXHiBC677DLEx8cjOzsb9913n8emx59//jnOOecc6HQ69O3bF2vXrvW4nVWrVqFXr17Q6/UYN24cvvvuuy54RN3D9yq8yB1jIEmSSwaqtK5V/n9uJExERJGgUwHU9ddfj8bGRo/Lm5ubcf3115/xSXljMpkwa9Ys3HbbbV6vt1gsuOyyy2AymfDNN9/glVdewdq1a11GKhw9ehSXXXYZpkyZgpKSEtx999248cYb8fHHH8vHrFu3DosWLcKyZcuwY8cOjBgxAtOnT0dVVVWXPK6uJpfw3HugIriJvLbZJGfOAFsGSuBGwkREFAk6FUC98soraG1t9bi8tbUVr7766hmflDcPPvggFi5ciGHDhnm9/pNPPsHevXvx2muvYeTIkbj00kvx0EMPYdWqVTCZTACA1atXo7i4GCtWrMCgQYOwYMECXHXVVS4lyZUrV+Kmm27C/PnzMXjwYKxevRrx8fFYs2ZNlzyurtbU5quEF7kZqOO1LS7fn3TOQJm4kTAREYVfUAGUwWBAQ0MDJElCY2MjDAaD/FVXV4cPPvgA2dnZXXWufm3ZsgXDhg1DTk6OfNn06dNhMBiwZ88e+Zhp06a5/Nz06dOxZcsWALYs1/bt212OUSqVmDZtmnxMtOlokGYk9kAdt/c/qZQKAK4BVKvcA8USHhERhU9Q70KpqalQKBRQKBTo37+/x/UKhQIPPvhgyE4uGBUVFS7BEwD5+4qKCr/HGAwGtLa2oq6uDhaLxesx+/fv93nfRqMRRqNR/t5gMPg8trvJYwx8zoGKwAyUvf9pRI8U7DhR71LCYw8UERFFgqDehTZv3gxJkjB16lS8/fbbSE9Pl6/TarUoKipCfn5+wLe3ePFiPP74436P2bdvHwYOHBjMaXa75cuXhy1w7IjB1yRyTeSOMRAB1MS+mdhxoh6N9llQKXEarsIjIqKIEFQANWnSJAC2ZuyePXtCoVCc0Z3fc889mDdvnt9jevfuHdBt5ebmeqyWq6yslK8T/xWXOR+TnJyMuLg4qFQqqFQqr8eI2/BmyZIlWLRokfy9wWBAYWFhQOfd1XxNItdHcBO5KOENzE1GRoIWp5tNOFnXgpS4FKceKGagiIgofDrVRF5UVISvvvoKc+bMwYQJE1BWVgYA+Mc//oGvvvoq4NvJysrCwIED/X5ptdqAbmv8+PH48ccfXVbLbdy4EcnJyRg8eLB8zKZNm1x+buPGjRg/3rbXmlarxejRo12OsVqt2LRpk3yMNzqdDsnJyS5fkUKU8JLdS3iR3ERuz0AVZcSjR3o8AEcfVIs9IEzQMQNFRETh06kA6u2338b06dMRFxeHHTt2yP0/DQ0NePTRR0N6gsKJEydQUlKCEydOwGKxoKSkBCUlJWhqagIAXHLJJRg8eDCuu+467Nq1Cx9//DF+//vf44477oBOpwMA3HrrrThy5Ajuv/9+7N+/H3/961/xr3/9CwsXLpTvZ9GiRfj73/+OV155Bfv27cNtt92G5uZmzJ8/v0seV1eSJEnOQCXq3DcTjswm8sa2dpxutq2aLMqIR4+0OACOAEpkoOJYwiMiojDqVAD18MMPY/Xq1fj73/8Ojcbxxjxx4kTs2LEjZCfnbOnSpRg1ahSWLVuGpqYmjBo1CqNGjcK2bdsAACqVCu+//z5UKhXGjx+POXPm4De/+Q3+9Kc/ybdRXFyMDRs2YOPGjRgxYgRWrFiBF198EdOnT5ePmT17Nv785z9j6dKlGDlyJEpKSvDRRx95NJZHg9Z2CyxWCYC/zYQjKwMlsk8ZCVok6TVOAZTt8lZ7AMVVeEREFE6dehc6cOAALrzwQo/LU1JSUF9ff6bn5NXatWu9Tg13VlRUhA8++MDvMZMnT8bOnTv9HrNgwQIsWLAg2FOMOKJ8p1R4zk2K1EnkJ+wzoHpm2Ep3PdJs/y2tFRkoDtIkIqLw61QGKjc3F4cPH/a4/Kuvvgq46Zu6nphCnqhTezT86zWR2UQu9sDrlZEAAB4ZqBb7GIMEjjEgIqIw6lQAddNNN+Guu+7Ct99+C4VCgVOnTuH111/HPffc43OrFep+jT6mkAOODFRbhI0xEHvg9bQ3jxfaA6iyulZIksQMFBERRYROfYxfvHgxrFYrLrroIrS0tODCCy+ETqfDfffdhxtvvDHU50id5GsKOQDoRAYqwprI5QxUpi2AKki1/bfRaIah1YwWEzNQREQUfp3KQCkUCvzud79DbW0tdu/eja1bt6K6uhopKSkoLi4O9TlSJ/kNoCK0idyRgbKV8OK0KmQm2kZZlNa1oNm+qjBOwwwUERGFT1ABlNFoxJIlSzBmzBhMnDgRH3zwAQYPHow9e/ZgwIABeOaZZ1xGAlB4NRm9TyEHAL3THChJkrr1vHxpa7eg3NAGAOhlbyIHgII0xywoZqCIiCgSBPUutHTpUvztb3/DtGnT8M0332DWrFmYP38+tm7dihUrVmDWrFlQqZgZiBSBZKAAWxClj4CMzsm6FkiSrek9PcExQLUwLQ67Sm174nErFyIiigRBBVDr16/Hq6++issvvxy7d+/G8OHDYTabsWvXrjPe1oVCz+A3gHIEIJESQB2rcUwgd/57EqMMfqpugn2sFTcTJiKisAqqhHfy5EmMHj0aADB06FDodDosXLiQwVOEcowx8CzhaVQKiF9bpIwyOF7rCKCciVEGByoa5cvYA0VEROEUVABlsVhc9qZTq9VITEwM+UlRaDT5yUApFAroxTDNCBllIDYRLrLPgBJEAHWw0rZtT5xGBZWSQTsREYVPUHUQSZIwb948eW+5trY23HrrrUhIcH3De+edd0J3htRpvjYSFnQaJVrbLZGTgRKbCKe7Z6Bs3zdxI2EiIooQQQVQc+fOdfl+zpw5IT0ZCq1G+yq8RF8BlLyhcHRkoARuJExEROEWVAD18ssvd9V5UBeQS3heeqCAyNoPz2yx4mSdbb879x4ovUaFzEQdapqMALiRMBERhV+nBmlSdPA3xgBwHqYZ/hLeqfo2mK0StGolcpP1Htc7Z6G4jQsREYUbA6gYZvCzFx7gNEwzAkp4x2tt5bue6fFQemkQdw6gOESTiIjCjQFUDHNMIo/8DNQxewN5L7fynSAayQFmoIiIKPwYQMWodotVbg73GUBpImc/vBOnRQYqwev1helOGSj2QBERUZgxgIpRov8JsG2N4o0uguZAyRmozAAyUBxjQEREYcYAKkaJFXhxGhXUKu+/Zr0mckp4YgVeYbqvAMq5iZwZKCIiCi8GUDHK0Oa//wlwZKAiYQ6UodV2vmnxWq/XF6RyFR4REUUOBlAxqqMRBkBkNZGLgM/X1HS9RoWsJNsEfPZAERFRuDGAilGNcgbK+wgDwDmACm8GymqV5G1a/J2vKOOxB4qIiMKNAVSMcgQkvrM18hyoMAdQjUYzJMn2//7Od8aQXCTr1RhdlNZNZ0ZEROQdayExKpgSXlt7eEt4IlumUyvloM6bWyb1wU0X9PY6aJOIiKg7MQMVo+QSno998ABAFyGTyA2tHZfvBAZPREQUCRhAxahGewkvMQqayEWwlxzHhCgREUUHBlAxKrhVeGHOQHWwZx8REVGkYQAVoxoDCEpECS/cPVBiBpSvEQZERESRhgFUjGqSe6AiPwPlKOExA0VERNGBAVSMCqyEFxljDEQJjxkoIiKKFgygYlRgJbwIayJnDxQREUUJBlAxKqBBmhGyF55jjAEzUEREFB0YQMUosbec3zEGEZKBMrAHioiIogwDqBjkurdcAE3kYc5ABdKvRUREFEkYQMWgZpNjbzl/fUWR00TOHigiIoouURNAPfLII5gwYQLi4+ORmprqcf2uXbtwzTXXoLCwEHFxcRg0aBCeeeYZl2M+//xzKBQKj6+KigqX41atWoVevXpBr9dj3Lhx+O6777ryoYWcyD6plQo5y+SNXhMpe+HZV+GxhEdERFEiamomJpMJs2bNwvjx4/HSSy95XL99+3ZkZ2fjtddeQ2FhIb755hvcfPPNUKlUWLBggcuxBw4cQHJysvx9dna2/P/r1q3DokWLsHr1aowbNw5PP/00pk+fjgMHDrgcF8mcS2IKhe+945wzUJIk+T22K4lBmizhERFRtIiad6wHH3wQALB27Vqv119//fUu3/fu3RtbtmzBO++84xFAZWdne81iAcDKlStx0003Yf78+QCA1atXY8OGDVizZg0WL158Zg+im8gbCXdQEhNN5ABgsljlgKo7SZLEEh4REUWdqCnhdUZDQwPS09M9Lh85ciTy8vJw8cUX4+uvv5YvN5lM2L59O6ZNmyZfplQqMW3aNGzZssXn/RiNRhgMBpevcAq0Kdu5vBeuPiij2Yp2i61hixkoIiKKFjEbQH3zzTdYt24dbr75ZvmyvLw8rF69Gm+//TbefvttFBYWYvLkydixYwcAoKamBhaLBTk5OS63lZOT49En5Wz58uVISUmRvwoLC7vmQQVIBFCJfrZxAQCtSglRtQvXSjxRvlMqgAQtAygiIooOYQ2gFi9e7LWp2/lr//79Qd/u7t278Ytf/ALLli3DJZdcIl8+YMAA3HLLLRg9ejQmTJiANWvWYMKECXjqqafO6HEsWbIEDQ0N8ldpaekZ3d6ZCmQKOQAoFI4m83A1khuczlWpDE8PFhERUbDC+pH/nnvuwbx58/we07t376Buc+/evbjoootw88034/e//32Hx48dOxZfffUVACAzMxMqlQqVlZUux1RWViI3N9fnbeh0Ouh0uqDOsys1GUVPUce/Xp1ahbZ2a9hKeIY2NpATEVH0Ceu7VlZWFrKyskJ2e3v27MHUqVMxd+5cPPLIIwH9TElJCfLy8gAAWq0Wo0ePxqZNmzBz5kwAgNVqxaZNmzwa0SOZXMILKIAK7zRyUcJjAzkREUWTqPnYf+LECdTW1uLEiROwWCwoKSkBAPTt2xeJiYnYvXs3pk6diunTp2PRokVyz5JKpZKDtKeffhrFxcUYMmQI2tra8OKLL+Kzzz7DJ598It/PokWLMHfuXIwZMwZjx47F008/jebmZnlVXjQIZrK3YzuX8GSgOIWciIiiUdS8ay1duhSvvPKK/P2oUaMAAJs3b8bkyZPx1ltvobq6Gq+99hpee+01+biioiIcO3YMgG2V3T333IOysjLEx8dj+PDh+PTTTzFlyhT5+NmzZ6O6uhpLly5FRUUFRo4ciY8++sijsTySBdoDBThvKByuHijug0dERNFHIUli0w8KFYPBgJSUFDQ0NLgM7OwuN7+6DZ/srcTDM4diznlFfo/92bP/w+4yA16efy6mDOj+QaGrv/gJj324H788pwArfzWy2++fiIhICOb9O2bHGJzNgirhiWnkYR5jwB4oIiKKJgygYpDYCy+QoCTcTeTcB4+IiKIRA6gY1BjEaAC9JswZqLbARy4QERFFCgZQMYhjDIiIiLoWA6gYFMwqPEcAxTEGREREgWIAFWOMZgtMFlswFFQTeZgnkbMHioiIogkDqBgjMjpAYJvz6jXh3QtPbiJnCY+IiKIIA6gYI/c/6dRQBbA5r04T5gxUK/fCIyKi6MMAKsY0BdlTJPdAhSEDZbZY0Wyy3S9LeEREFE0YQMWYYEYYAOFtIhfzqgBmoIiIKLowgIoxBqcSXiB0YdwLz9BqO9c4jQoaFf8UiYgoevBdK8Y4MlCBlcREE3k4MlCOFXjMPhERUXRhABVjgp2rFM4xBoYggz0iIqJIwQAqxgQzRBMAdJrwTSIXJTxu40JERNGGAVSMaQxybznHKrzuz0AFW24kIiKKFAygYkzQJTz7HKi2cGSgxBBNjjAgIqIowwAqxjQag8vqREYGiiU8IiKKLgygYoy8NUqAK9vC2kTeym1ciIgoOjGAijGiLJakCzIDFZYSHscYEBFRdGIAFWMag9xbTi96oNhETkREFDAGUDHGEOwYg3BmoDjGgIiIohQDqBgT9F54TpPIJUnqsvPyRjS8sweKiIiiDQOoGGIyW+Vm8ECDEtFELklAu6V7Ayg5A8UeKCIiijIMoGKIyD4BQGKQgzSB7p8FJTeRMwNFRERRhgFUDBEjDBK0KqiUioB+xjmA6s5ZUJIkBb3tDBERUaRgABVDOhOQKBSKsDSSt5gssFhtJUOW8IiIKNowgIohnZ3s7Qigui8DJYI9lVKBOPsoBSIiomjBACqGdHZvOXk/vPbuy0AZnDY9VigCKzcSERFFCgZQMcTQyQyUXtP9GShDq5hCzv4nIiKKPgygYkhnm7Ll/fC6sYncca7sfyIioujDACqGnHkPVDhKeMxAERFR9GEAFUM6m9URAVR37odnYAaKiIiiGAOoGNLYyayO2FC4WzNQrcxAERFR9GIAFUPONAMVjjEGHKJJRETRKGoCqEceeQQTJkxAfHw8UlNTvR6jUCg8vt58802XYz7//HOcc8450Ol06Nu3L9auXetxO6tWrUKvXr2g1+sxbtw4fPfdd13wiEKv8wGUyEB1ZwlPrMJjCY+IiKJP1ARQJpMJs2bNwm233eb3uJdffhnl5eXy18yZM+Xrjh49issuuwxTpkxBSUkJ7r77btx44434+OOP5WPWrVuHRYsWYdmyZdixYwdGjBiB6dOno6qqqqseWsjITeS6YOdA2TNQ3TkHiiU8IiKKYlHz8f/BBx8EAK8ZI2epqanIzc31et3q1atRXFyMFStWAAAGDRqEr776Ck899RSmT58OAFi5ciVuuukmzJ8/X/6ZDRs2YM2aNVi8eHGIHk3XaOzkIE19GDJQHGNARETRLGoyUIG64447kJmZibFjx2LNmjWQJEm+bsuWLZg2bZrL8dOnT8eWLVsA2LJc27dvdzlGqVRi2rRp8jHeGI1GGAwGl69w6OwgzbBkoNo4SJOIiKJXTH38/9Of/oSpU6ciPj4en3zyCW6//XY0NTXh//7v/wAAFRUVyMnJcfmZnJwcGAwGtLa2oq6uDhaLxesx+/fv93m/y5cvlzNk4dTZ0QDhbSKPqT9BIiI6S4Q1A7V48WKvjd/OX/4CF3d/+MMfMHHiRIwaNQq//e1vcf/99+PJJ5/swkdgs2TJEjQ0NMhfpaWlXX6f7oxmC0z2AKjTk8jDsZULe6CIiCgKhfXj/z333IN58+b5PaZ3796dvv1x48bhoYcegtFohE6nQ25uLiorK12OqaysRHJyMuLi4qBSqaBSqbwe46uvCgB0Oh10Ol2nzzMUREYHABJ1nR2k2f0lvBSW8IiIKAqFNYDKyspCVlZWl91+SUkJ0tLS5OBm/Pjx+OCDD1yO2bhxI8aPHw8A0Gq1GD16NDZt2iSv3rNardi0aRMWLFjQZecZCiKAStSpoVIqgvpZxyDN7slAmcxWeeo5S3hERBSNoubd68SJE6itrcWJEydgsVhQUlICAOjbty8SExPx3//+F5WVlTjvvPOg1+uxceNGPProo7j33nvl27j11lvx3HPP4f7778f111+Pzz77DP/617+wYcMG+ZhFixZh7ty5GDNmDMaOHYunn34azc3N8qq8SNXZffAApybyLppE/t7OMuyrMOCui/ohXquWzxUIPltGREQUCaLm3Wvp0qV45ZVX5O9HjRoFANi8eTMmT54MjUaDVatWYeHChZAkCX379pVHEgjFxcXYsGEDFi5ciGeeeQY9evTAiy++KI8wAIDZs2ejuroaS5cuRUVFBUaOHImPPvrIo7E80pxJU7bcRN5Fe+Et/fduGNrM2PLTabw4dwxajLZALUGrgloVcwtBiYjoLBA1AdTatWv9zoCaMWMGZsyY0eHtTJ48GTt37vR7zIIFCyK+ZOfOkYEKvqdINJG3dUEGqsVkllcH/nCyAVes+gYLL+4PgCMMiIgoekVNAEX+GVo7n4HSa7ouA1VlMAKwZbnyU+NwtKYZ9721CwD7n4iIKHqxfhIj5MGUZ5CB6oom8qpGWwCVm6LHO7dNwLm90iBmm3KEARERRSsGUDEiJD1QXVDCq7YHUNlJOqQlaPGPG8bh8hH5AIBemQkhvz8iIqLuwBpKFNld1oDvj9Wib3YiLujnOv7BEUB1IgOlEXOguiID1QYAyE7SA7CNTHh69kjMndALA3KTQn5/RERE3YEZqCiyaV8VHvzvXry/q9zjujMaYyCX8EKfgRIlvKwkx6BRpVKB0UVpHGFARERRiwFUFMlPtWVxTjW0elwnMlDJZ9JE3hU9UAbPAIqIiCjaMYCKIgWpcQCAsnovAZTxzMcYOK/Cs1olrPjkANZvO7N9/RwlPAZQREQUO1hDiSL59gDqVH0rJEmCQuHYsiUUTeRtZot8u18eqsaznx1GglaFWWMKO33OchN5sr7Tt0FERBRpmIGKIrkptiCkrd2KupZ2l+vOqIncnoGSJKDdYpsx8N7OMgBAs8mCFpPZ5892xHkVHhERUaxgABVF9BoVMhNtgcgptzKeofXM98IDbI3kzUYzPt5TKV92usnUmdNFu8WK0822n2UPFBERxRIGUFGmwN5I7t4HJTeRd2J7FFHCA2yN5B/trkBru2NFXk2TsTOnKv+cWqlAery2U7dBREQUiRhARRnnPiihrd0Ck8XWAN6ZDJRCoYBW9EG1W/CuvXwndDYDJVbgZSbqoFQqOjiaiIgoejCAijIigCpvaJMvE9knhQJI1HZuXYDIQp2obcHXP9UAAPplJwIATjd3LgPlaCBn+Y6IiGILA6gok+9llIEYopmoVXc606PX2BrJ1287CUkCxhSlYURhKgDIfUzBqmIDORERxSgGUFFG9ECdcgmgOj/CQBAZqA9+tE05v+KcAmQk2vqWOl3Cs8+AYgM5ERHFGgZQUcZbD9SZjDAQHBsKW6FVKfGzYfnITLAFPqc72UTu2MaFM6CIiCi2MICKMiKAqmo0wmTfeuVM9sETxCwoAJg6MBsp8RpHBqqzJTwDS3hERBSbGEBFmYwELbRqJSQJqDTYSmShKOHpnWZBXXFOAQAgPeHMSnjVTQygiIgoNjGAijIKhcJjTzxDW+f3wRNEBiolToPJA7IAQB7a2elVePYAj9u4EBFRrGEAFYXy3RrJDfIQzTMo4dkzUD8bnicHU85N5JIkBXV7kiTJGSg2kRMRUazhZsJRKD/FtZG8MQQZqKtG90B9SztuvrC3fJko4ZmtEgytZqTEB377dS3t8r56WYkMoIiIKLYwgIpCjllQoeuB+tnwfPxseL7LZTq1Ckk6NRqNZpxuNgYVQIkRBmnxGnnKORERUazgO1sUKkgNfQbKl86uxJOnkHOEARERxSAGUFHIfRaUvJHwGWSgfMlI7NwsKHmEAbdxISKiGMQAKgo5N5FLkhSSEp4vGfY+qJogRxnIQzTZ/0RERDGIAVQUEhmoZpMFhlZzt5TwaoMs4cnbuDADRUREMYgBVBTSa1RyZqisvrWLM1CdLOGxB4qIiGIYA6gole80TDMUgzR9ERmomk43kTMDRUREsYcBVJQSfVBHa5rkeUtdkYFybOcSXAaKARQREcUyBlBRSmSg9lc0AgAUCiBRG/oASmznEnQPlH0bF04hJyKiWMQAKkqJWVAH7AFUok4NpVIR8vtx3s4lUM1GM5pNFgDcB4+IiGITA6goJTJQh6qaAADJXdD/BDiayGtbTLBYA9sPTzSQx2tVSNRx2D0REcUeBlBRSgRQJrMVQNf0PwG2rVgAQJKAupbAslDsfyIiolgXNQHUI488ggkTJiA+Ph6pqake169duxYKhcLrV1VVFQDg888/93p9RUWFy22tWrUKvXr1gl6vx7hx4/Ddd991x0MMimgiF7oqgFKrlHIQFWgflJgBxREGREQUq6ImgDKZTJg1axZuu+02r9fPnj0b5eXlLl/Tp0/HpEmTkJ2d7XLsgQMHXI5zvn7dunVYtGgRli1bhh07dmDEiBGYPn26HIRFiswEHbQqx6+vK0YYCGI7l5oAV+KJbVzYQE5ERLEqagKoBx98EAsXLsSwYcO8Xh8XF4fc3Fz5S6VS4bPPPsMNN9zgcWx2drbLsUql42lYuXIlbrrpJsyfPx+DBw/G6tWrER8fjzVr1nTZY+sMpVKBPKcsVFdloADHdi6BNpLL27gwgCIiohgVNQFUsF599VXEx8fjqquu8rhu5MiRyMvLw8UXX4yvv/5avtxkMmH79u2YNm2afJlSqcS0adOwZcuWbjnvYOSnxMn/36UBVGJws6DkEh63cSEiohgVswHUSy+9hF//+teIi3MEGXl5eVi9ejXefvttvP322ygsLMTkyZOxY8cOAEBNTQ0sFgtycnJcbisnJ8ejT8qZ0WiEwWBw+eoOopEc6OISXkJws6CquY0LERHFuLAGUIsXL/bZ+C2+9u/fH/TtbtmyBfv27fMo3w0YMAC33HILRo8ejQkTJmDNmjWYMGECnnrqqTN6HMuXL0dKSor8VVhYeEa3F6gCpxJeV40xAILfzoWr8IiIKNaFdUjPPffcg3nz5vk9pnfv3kHf7osvvoiRI0di9OjRHR47duxYfPXVVwCAzMxMqFQqVFZWuhxTWVmJ3Nxcn7exZMkSLFq0SP7eYDB0SxDlmoHqyhKe9w2FJUnCnf/ciWajGc/++hx55hN7oIiIKNaFNYDKyspCVlZWSG+zqakJ//rXv7B8+fKAji8pKUFeXh4AQKvVYvTo0di0aRNmzpwJALBardi0aRMWLFjg8zZ0Oh10uu4PFrotgPLRRH78dAve/6EcAHDH6zvw0twxsEqOUh8zUEREFKuiZkz0iRMnUFtbixMnTsBisaCkpAQA0LdvXyQmJsrHrVu3DmazGXPmzPG4jaeffhrFxcUYMmQI2tra8OKLL+Kzzz7DJ598Ih+zaNEizJ07F2PGjMHYsWPx9NNPo7m5GfPnz+/yxxgs5wCqS0t49gDKvQdqZ2md/P9fHKzGH/69B3dO7QsAUCsVSIvXdtk5ERERhVPUBFBLly7FK6+8In8/atQoAMDmzZsxefJk+fKXXnoJv/zlL70O2zSZTLjnnntQVlaG+Ph4DB8+HJ9++immTJkiHzN79mxUV1dj6dKlqKiowMiRI/HRRx95NJZHgvzuGmPgYw7UjuP1AIDhPVLwY1kD/vndCRja2gHYynddsTcfERFRJFBIkhTYBmcUMIPBgJSUFDQ0NCA5OblL72vco5+i0mDEF/dNRlFGQpfcR32LCSP/tBEAcPDhS6FV29Ye/OzZ/2F3mQHP/XoUqhuNePC/e+WfGdEjBf9ecH6XnA8REVFXCOb9O2oyUOTdX64ehdK61i4LngBbeVClVMBilVDbbEJuih6tJgv2lTcCAEb1TENBahxKa1ux5uujANhATkREsS1m50CdLcb1zsBVo3t06X0olQqki0byZlsZ78eyBlisErKTdMhPsZUSf3fZIEwfYit19slO9H5jREREMYAZKApIRoIW1Y1GeSXezhO2BvJRPVOhUNh6nVRKBZ695hx8fbgG5xanh+1ciYiIuhoDKApIZqIOQKOcgdp5oh6ArXznTKtWYsrAbBAREcUylvAoIOlOs6AkScIOewbqHLcAioiI6GzAAIoCIm8o3GxCeUMbqhqNUCkVGFaQEuYzIyIi6n4MoCggmU7buYjy3aC8JMRpVWE8KyIiovBgAEUBcd7ORW4gL2T5joiIzk5sIqeAiB6ommYT6ltt08ZH9UwN4xkRERGFDwMoCojYzqWyoQ21LbZRBu4r8IiIiM4WDKAoIJn2JvIKQxsAIDVeg14Z8eE8JSIiorBhDxQFRGSghFGFjgGaREREZxsGUBSQBK1K3kQYYPmOiIjObgygKCAKhQKZ9kZygA3kRER0dmMARQETZTyFAhhRmBrekyEiIgojBlAUMDGNvG9WIpL1mjCfDRERUfgwgKKAiVlQLN8REdHZjgEUBezSoXnokRaHK8/pEe5TISIiCivOgaKAXTw4BxcPzgn3aRAREYUdM1BEREREQWIARURERBQkBlBEREREQWIARURERBQkBlBEREREQWIARURERBQkBlBEREREQWIARURERBQkBlBEREREQWIARURERBQkBlBEREREQWIARURERBQkBlBEREREQWIARURERBQkdbhPIBZJkgQAMBgMYT4TIiIiCpR43xbv4/4wgOoCjY2NAIDCwsIwnwkREREFq7GxESkpKX6PUUiBhFkUFKvVilOnTiEpKQkKhSKkt20wGFBYWIjS0lIkJyeH9LbJFZ/r7sPnuvvwue4+fK67T6iea0mS0NjYiPz8fCiV/rucmIHqAkqlEj169OjS+0hOTuY/yG7C57r78LnuPnyuuw+f6+4Tiue6o8yTwCZyIiIioiAxgCIiIiIKEgOoKKPT6bBs2TLodLpwn0rM43Pdffhcdx8+192Hz3X3CcdzzSZyIiIioiAxA0VEREQUJAZQREREREFiAEVEREQUJAZQREREREFiABVFVq1ahV69ekGv12PcuHH47rvvwn1KUW/58uU499xzkZSUhOzsbMycORMHDhxwOaatrQ133HEHMjIykJiYiCuvvBKVlZVhOuPY8dhjj0GhUODuu++WL+NzHTplZWWYM2cOMjIyEBcXh2HDhmHbtm3y9ZIkYenSpcjLy0NcXBymTZuGQ4cOhfGMo5PFYsEf/vAHFBcXIy4uDn369MFDDz3kspcan+vO+fLLL/Hzn/8c+fn5UCgUeO+991yuD+R5ra2txbXXXovk5GSkpqbihhtuQFNTU0jOjwFUlFi3bh0WLVqEZcuWYceOHRgxYgSmT5+OqqqqcJ9aVPviiy9wxx13YOvWrdi4cSPa29txySWXoLm5WT5m4cKF+O9//4v169fjiy++wKlTp/DLX/4yjGcd/b7//nv87W9/w/Dhw10u53MdGnV1dZg4cSI0Gg0+/PBD7N27FytWrEBaWpp8zBNPPIG//OUvWL16Nb799lskJCRg+vTpaGtrC+OZR5/HH38czz//PJ577jns27cPjz/+OJ544gk8++yz8jF8rjunubkZI0aMwKpVq7xeH8jzeu2112LPnj3YuHEj3n//fXz55Ze4+eabQ3OCEkWFsWPHSnfccYf8vcVikfLz86Xly5eH8axiT1VVlQRA+uKLLyRJkqT6+npJo9FI69evl4/Zt2+fBEDasmVLuE4zqjU2Nkr9+vWTNm7cKE2aNEm66667JEnicx1Kv/3tb6Xzzz/f5/VWq1XKzc2VnnzySfmy+vp6SafTSf/85z+74xRjxmWXXSZdf/31Lpf98pe/lK699lpJkvhchwoA6d1335W/D+R53bt3rwRA+v777+VjPvzwQ0mhUEhlZWVnfE7MQEUBk8mE7du3Y9q0afJlSqUS06ZNw5YtW8J4ZrGnoaEBAJCeng4A2L59O9rb212e+4EDB6Jnz5587jvpjjvuwGWXXebynAJ8rkPpP//5D8aMGYNZs2YhOzsbo0aNwt///nf5+qNHj6KiosLluU5JScG4ceP4XAdpwoQJ2LRpEw4ePAgA2LVrF7766itceumlAPhcd5VAntctW7YgNTUVY8aMkY+ZNm0alEolvv322zM+B24mHAVqampgsViQk5PjcnlOTg72798fprOKPVarFXfffTcmTpyIoUOHAgAqKiqg1WqRmprqcmxOTg4qKirCcJbR7c0338SOHTvw/fffe1zH5zp0jhw5gueffx6LFi3CAw88gO+//x7/93//B61Wi7lz58rPp7fXFD7XwVm8eDEMBgMGDhwIlUoFi8WCRx55BNdeey0A8LnuIoE8rxUVFcjOzna5Xq1WIz09PSTPPQMoIrs77rgDu3fvxldffRXuU4lJpaWluOuuu7Bx40bo9fpwn05Ms1qtGDNmDB599FEAwKhRo7B7926sXr0ac+fODfPZxZZ//etfeP311/HGG29gyJAhKCkpwd133438/Hw+1zGOJbwokJmZCZVK5bEaqbKyErm5uWE6q9iyYMECvP/++9i8eTN69OghX56bmwuTyYT6+nqX4/ncB2/79u2oqqrCOeecA7VaDbVajS+++AJ/+ctfoFarkZOTw+c6RPLy8jB48GCXywYNGoQTJ04AgPx88jXlzN13331YvHgxrr76agwbNgzXXXcdFi5ciOXLlwPgc91VAnlec3NzPRZamc1m1NbWhuS5ZwAVBbRaLUaPHo1NmzbJl1mtVmzatAnjx48P45lFP0mSsGDBArz77rv47LPPUFxc7HL96NGjodFoXJ77AwcO4MSJE3zug3TRRRfhxx9/RElJifw1ZswYXHvttfL/87kOjYkTJ3qM4zh48CCKiooAAMXFxcjNzXV5rg0GA7799ls+10FqaWmBUun6VqpSqWC1WgHwue4qgTyv48ePR319PbZv3y4f89lnn8FqtWLcuHFnfhJn3IZO3eLNN9+UdDqdtHbtWmnv3r3SzTffLKWmpkoVFRXhPrWodtttt0kpKSnS559/LpWXl8tfLS0t8jG33nqr1LNnT+mzzz6Ttm3bJo0fP14aP358GM86djivwpMkPteh8t1330lqtVp65JFHpEOHDkmvv/66FB8fL7322mvyMY899piUmpoq/fvf/5Z++OEH6Re/+IVUXFwstba2hvHMo8/cuXOlgoIC6f3335eOHj0qvfPOO1JmZqZ0//33y8fwue6cxsZGaefOndLOnTslANLKlSulnTt3SsePH5ckKbDndcaMGdKoUaOkb7/9Vvrqq6+kfv36Sddcc01Izo8BVBR59tlnpZ49e0parVYaO3astHXr1nCfUtQD4PXr5Zdflo9pbW2Vbr/9diktLU2Kj4+XrrjiCqm8vDx8Jx1D3AMoPteh89///lcaOnSopNPppIEDB0ovvPCCy/VWq1X6wx/+IOXk5Eg6nU666KKLpAMHDoTpbKOXwWCQ7rrrLqlnz56SXq+XevfuLf3ud7+TjEajfAyf687ZvHmz19fnuXPnSpIU2PN6+vRp6ZprrpESExOl5ORkaf78+VJjY2NIzk8hSU7jUomIiIioQ+yBIiIiIgoSAygiIiKiIDGAIiIiIgoSAygiIiKiIDGAIiIiIgoSAygiIiKiIDGAIiIiIgoSAygiOqsdO3YMCoUCJSUlXXYf8+bNw8yZM7vs9omo+zGAIqKoNm/ePCgUCo+vGTNmBPTzhYWFKC8vx9ChQ7v4TIkolqjDfQJERGdqxowZePnll10u0+l0Af2sSqUKyc7sRHR2YQaKiKKeTqdDbm6uy1daWhoAQKFQ4Pnnn8ell16KuLg49O7dG2+99Zb8s+4lvLq6Olx77bXIyspCXFwc+vXr5xKc/fjjj5g6dSri4uKQkZGBm2++GU1NTfL1FosFixYtQmpqKjIyMnD//ffDfccsq9WK5cuXo7i4GHFxcRgxYoTLOXV0DkQUfgygiCjm/eEPf8CVV16JXbt24dprr8XVV1+Nffv2+Tx27969+PDDD7Fv3z48//zzyMzMBAA0Nzdj+vTpSEtLw/fff4/169fj008/xYIFC+SfX7FiBdauXYs1a9bgq6++Qm1tLd59912X+1i+fDleffVVrF69Gnv27MHChQsxZ84cfPHFFx2eAxFFiJBsSUxEFCZz586VVCqVlJCQ4PL1yCOPSJIkSQCkW2+91eVnxo0bJ912222SJEnS0aNHJQDSzp07JUmSpJ///OfS/Pnzvd7XCy+8IKWlpUlNTU3yZRs2bJCUSqVUUVEhSZIk5eXlSU888YR8fXt7u9SjRw/pF7/4hSRJktTW1ibFx8dL33zzjctt33DDDdI111zT4TkQUWRgDxQRRb0pU6bg+eefd7ksPT1d/v/x48e7XDd+/Hifq+5uu+02XHnlldixYwcuueQSzJw5ExMmTAAA7Nu3DyNGjEBCQoJ8/MSJE2G1WnHgwAHo9XqUl5dj3Lhx8vVqtRpjxoyRy3iHDx9GS0sLLr74Ypf7NZlMGDVqVIfnQESRgQEUEUW9hIQE9O3bNyS3demll+L48eP44IMPsHHjRlx00UW444478Oc//zkkty/6pTZs2ICCggKX60Tje1efAxGdOfZAEVHM27p1q8f3gwYN8nl8VlYW5s6di9deew1PP/00XnjhBQDAoEGDsGvXLjQ3N8vHfv3111AqlRgwYABSUlKQl5eHb7/9Vr7ebDZj+/bt8veDBw+GTqfDiRMn0LdvX5evwsLCDs+BiCIDM1BEFPWMRiMqKipcLlOr1XLj9fr16zFmzBicf/75eP311/Hdd9/hpZde8npbS5cuxejRozFkyBAYjUa8//77crB17bXXYtmyZZg7dy7++Mc/orq6GnfeeSeuu+465OTkAADuuusuPPbYY+jXrx8GDhyIlStXor6+Xr79pKQk3HvvvVi4cCGsVivOP/98NDQ04Ouvv0ZycjLmzp3r9xyIKDIwgCKiqPfRRx8hLy/P5bIBAwZg//79AIAHH3wQb775Jm6//Xbk5eXhn//8JwYPHuz1trRaLZYsWYJjx44hLi4OF1xwAd58800AQHx8PD7++GPcddddOPfccxEfH48rr7wSK1eulH/+nnvuQXl5OebOnQulUonrr78eV1xxBRoaGuRjHnroIWRlZWH58uU4cuQIUlNTcc455+CBBx7o8ByIKDIoJMltQAkRUQxRKBR49913uZUKEYUUe6CIiIiIgsQAioiIiChI7IEiopjGLgUi6grMQBEREREFiQEUERERUZAYQBEREREFiQEUERERUZAYQBEREREFiQEUERERUZAYQBEREREFiQEUERERUZAYQBEREREF6f8Dw7wM1knRWVcAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title(f'SAC on {env_name}')\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title(f'SAC on {env_name}')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c3a53945",
   "metadata": {},
   "outputs": [],
   "source": [
    "rl_utils.play_game(env_name, agent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "83859753",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PolicyNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return F.softmax(self.fc2(x), dim=1)\n",
    "\n",
    "class QValueNet(torch.nn.Module):\n",
    "    ''' 只有一层隐藏层的Q网络 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return self.fc2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b2e842a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SAC:\n",
    "    ''' 处理离散动作的SAC算法 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, actor_lr, critic_lr, alpha_lr, target_entropy, tau, gamma, device):\n",
    "        # 策略网络\n",
    "        self.actor = PolicyNet(state_dim, action_dim, action_dim).to(device)\n",
    "        # 第一个Q网络\n",
    "        self.critic_1 = QValueNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        # 第二个Q网络\n",
    "        self.critic_2 = QValueNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        # 第一个目标Q网络\n",
    "        self.target_critic_1 = QValueNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        # 第二个目标Q网络\n",
    "        self.target_critic_2 = QValueNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        # 令目标Q网络的初始化参数和Q网络一样\n",
    "        self.target_critic_1.load_state_dict(self.critic_1.state_dict())\n",
    "        self.target_critic_2.load_state_dict(self.critic_2.state_dict())\n",
    "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=actor_lr)\n",
    "        self.critic_1_optimizer = torch.optim.Adam(self.critic_1.parameters(), lr=critic_lr)\n",
    "        self.critic_2_optimizer = torch.optim.Adam(self.critic_2.parameters(), lr=critic_lr)\n",
    "        # 使用alpha的log值，可以使训练结果比较稳定\n",
    "        self.log_alpha = torch.tensor(np.log(0.01), dtype=torch.float)\n",
    "        # 可以对alpha求梯度\n",
    "        self.log_alpha.requires_grad = True\n",
    "        self.log_alpha_optimizer = torch.optim.Adam([self.log_alpha], lr=alpha_lr)\n",
    "        # 目标熵的大小\n",
    "        self.target_entropy = target_entropy\n",
    "        self.gamma = gamma\n",
    "        self.tau = tau\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self, state):\n",
    "        state = torch.tensor([state], dtype=torch.float).to(self.device)\n",
    "        probs = self.actor(state)\n",
    "        action_dist = torch.distributions.Categorical(probs)\n",
    "        action = action_dist.sample()\n",
    "        return action.item()\n",
    "    \n",
    "    # 计算目标Q值,直接用策略网络的输出概率进行期望计算\n",
    "    def calc_target(self, rewards, next_states, dones):\n",
    "        ''' \n",
    "        H(p)=−∑p(x)logp(x)\n",
    "        '''\n",
    "        # 获取动作概率分布\n",
    "        next_probs = self.actor(next_states)\n",
    "        # 计算对数概率，添加小常数避免数值问题\n",
    "        next_log_probs = torch.log(next_probs + 1e-8)\n",
    "        # 计算分布熵\n",
    "        entropy = -torch.sum(next_probs * next_log_probs, dim=1, keepdim=True)\n",
    "        # 假设Q网络直接接受状态，输出各动作的Q值\n",
    "        q1_value = self.target_critic_1(next_states)\n",
    "        # 同上\n",
    "        q2_value = self.target_critic_2(next_states)\n",
    "        # 对Q值取最小，并按动作概率加权平均\n",
    "        min_qvalue = torch.sum(next_probs * torch.min(q1_value, q2_value), dim=1, keepdim=True)\n",
    "        # 加入熵正则化项\n",
    "        next_value = min_qvalue + self.log_alpha.exp() * entropy\n",
    "        # 构建TD目标\n",
    "        td_target = rewards + self.gamma * next_value * (1 - dones)\n",
    "        return td_target\n",
    "    \n",
    "    def soft_update(self, net, target_net):\n",
    "        for param_target, param in zip(target_net.parameters(), net.parameters()):\n",
    "            param_target.data.copy_(param_target.data * (1.0 - self.tau) + param.data * self.tau)\n",
    "    \n",
    "    def update(self, transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(self.device)\n",
    "        # 动作不再是float类型\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "\n",
    "        # 更新两个Q网络\n",
    "        td_target = self.calc_target(rewards, next_states, dones)\n",
    "        critic_1_q_values = self.critic_1(states).gather(1, actions)\n",
    "        critic_2_q_values = self.critic_2(states).gather(1, actions)\n",
    "        critic_1_loss = torch.mean(F.mse_loss(critic_1_q_values, td_target.detach()))\n",
    "        critic_2_loss = torch.mean(F.mse_loss(critic_2_q_values, td_target.detach()))\n",
    "        self.critic_1_optimizer.zero_grad()\n",
    "        self.critic_2_optimizer.zero_grad()\n",
    "        critic_1_loss.backward()\n",
    "        critic_2_loss.backward()\n",
    "        self.critic_1_optimizer.step()\n",
    "        self.critic_2_optimizer.step()\n",
    "\n",
    "        # 更新策略网络\n",
    "        probs = self.actor(states)\n",
    "        log_probs = torch.log(probs + 1e-8)\n",
    "        # 直接根据概率计算熵\n",
    "        entropy = -torch.sum(probs * log_probs, dim=1, keepdim=True)\n",
    "        q1_value = self.critic_1(states)\n",
    "        q2_value = self.critic_2(states)\n",
    "        # 直接根据概率计算期望\n",
    "        min_qvalue = torch.sum(probs * torch.min(q1_value, q2_value), dim=1, keepdim=True)\n",
    "        actor_loss = torch.mean(-self.log_alpha.exp() * entropy - min_qvalue)\n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "\n",
    "        # 更新alpha值\n",
    "        alpha_loss = -torch.mean((log_probs + self.target_entropy).detach() * self.log_alpha.exp())\n",
    "        self.log_alpha_optimizer.zero_grad()\n",
    "        alpha_loss.backward()\n",
    "        self.log_alpha_optimizer.step()\n",
    "\n",
    "        self.soft_update(self.critic_1, self.target_critic_1)\n",
    "        self.soft_update(self.critic_2, self.target_critic_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e7ebf263",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|██████████| 100/100 [01:23<00:00,  1.20it/s, episode=100, return=201.700]\n",
      "Iteration 1: 100%|██████████| 100/100 [03:23<00:00,  2.03s/it, episode=200, return=220.200]\n",
      "Iteration 2: 100%|██████████| 100/100 [02:26<00:00,  1.46s/it, episode=300, return=217.900]\n",
      "Iteration 3: 100%|██████████| 100/100 [03:26<00:00,  2.07s/it, episode=400, return=496.900]\n",
      "Iteration 4: 100%|██████████| 100/100 [03:40<00:00,  2.20s/it, episode=500, return=488.400]\n",
      "Iteration 5: 100%|██████████| 100/100 [04:19<00:00,  2.60s/it, episode=600, return=444.100]\n",
      "Iteration 6: 100%|██████████| 100/100 [03:30<00:00,  2.10s/it, episode=700, return=327.800]\n",
      "Iteration 7: 100%|██████████| 100/100 [02:37<00:00,  1.58s/it, episode=800, return=9.400] \n",
      "Iteration 8: 100%|██████████| 100/100 [00:09<00:00, 10.90it/s, episode=900, return=10.300]\n",
      "Iteration 9: 100%|██████████| 100/100 [01:23<00:00,  1.20it/s, episode=1000, return=333.900]\n"
     ]
    }
   ],
   "source": [
    "actor_lr = 1e-3\n",
    "critic_lr = 1e-2\n",
    "alpha_lr = 1e-2\n",
    "num_episodes = 1000\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "# 软更新参数\n",
    "tau = 0.005\n",
    "buffer_size = 10000\n",
    "minimal_size = 500\n",
    "batch_size = 64\n",
    "target_entropy = -1\n",
    "device = 'cpu'\n",
    "\n",
    "env_name = 'CartPole-v1'\n",
    "env = gym.make(env_name)\n",
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "torch.manual_seed(0)\n",
    "replay_buffer = rl_utils.ReplayBuffer(buffer_size)\n",
    "state_dim = env.observation_space.shape[0]\n",
    "action_dim = env.action_space.n\n",
    "agent = SAC(state_dim, hidden_dim, action_dim, actor_lr, critic_lr, alpha_lr, target_entropy, tau, gamma, device)\n",
    "return_list = rl_utils.train_off_policy_agent(env, agent, num_episodes, replay_buffer, minimal_size, batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b3bea6c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAidlJREFUeJzt3Xd4VGXaP/DvmZlkUie9QggJvVdFFBEFKRZUsOCiIrq6q+irsLou7/7Esu6ya93VxbLvKvay9sWC0i0UkS69BAikkTqpU8/vjzPnzDmTmZTJJDMZvp/ryiWZOTN5hpjJzV2eRxBFUQQRERFRmNIFewFEREREnYnBDhEREYU1BjtEREQU1hjsEBERUVhjsENERERhjcEOERERhTUGO0RERBTWGOwQERFRWGOwQ0RERGGNwQ4RUZCtX78egiBg/fr1wV4KUVhisEPUjezZswfXXnstcnNzERUVhR49euDSSy/FCy+84PMx119/PQRBwEMPPdTic+/cuRM33XQTcnJyYDQakZycjClTpmD58uVwOByBfil+czgcWL58OSZNmoTk5GQYjUb07t0b8+fPx88//xzQr7Vx40Y8+uijqK6ubnZf7969IQiC8pGeno4LL7wQn376aUDX0NleeuklXHfddejVqxcEQcCtt94a7CURBRyDHaJuYuPGjRg7dix27dqFO+64A//85z/x61//GjqdDv/4xz+8PsZsNmPFihXo3bs33nvvPfg6Cu/f//43xo4di3Xr1mHu3Ll48cUXsWTJEkRHR+P222/H3/72t858aW3W2NiIK664ArfddhtEUcT//u//4qWXXsItt9yCTZs24dxzz8WpU6cC9vU2btyIxx57zGuwAwAjR47EW2+9hbfeegsPPPAAioqKMGvWLLz88ssBW0Nn+9vf/oa1a9diyJAhMBgMwV4OUecQiahbuOyyy8S0tDSxqqqq2X2lpaVeH/Paa6+JERER4tq1a0UA4vr165tds2nTJlGv14sTJkwQzWZzs/u3bt0qLl++vKPLD4gFCxaIAMTnnnuu2X12u1186qmnxMLCwg5/nbq6OlEURfGpp54SAYgFBQXNrsnNzRUvv/xyzW3FxcVibGys2L9//3Z9vXXr1okAxHXr1vm7ZL8dP35cdDqdoiiKYmxsrDhv3rwuXwNRZ2Nmh6ibOHr0KIYMGYLExMRm96Wnp3t9zDvvvINLL70UF198MQYNGoR33nmn2TWPPfYYBEHAO++8g/j4+Gb3jx07tk2ljRdffBFDhgyB0WhEdnY2FixY0CwjMmnSJAwdOhT79u3DxRdfjJiYGPTo0QNPPvlkq89/6tQpvPLKK7j00ktx//33N7tfr9fjgQceQM+ePQEAJ06cwN13340BAwYgOjoaKSkpuO6663D8+HHN415//XUIgoANGzbg7rvvRnp6Onr27IlHH30UDz74IAAgLy9PKVd5Pl4tMzMTgwYNQkFBgXLbjh07MGPGDJhMJsTFxWHy5MnYvHlzq68XALZs2YLp06cjISEBMTExuOiii/Djjz+2+BibzYbk5GTMnz+/2X1msxlRUVF44IEHlNtyc3MhCEKb1kPUXTHYIeomcnNzsW3bNvzyyy9tur6oqAjr1q3DjTfeCAC48cYb8dFHH8FqtSrXNDQ0YM2aNZg4cSJ69erl99oeffRRLFiwANnZ2XjmmWcwe/ZsvPLKK5g6dSpsNpvm2qqqKkyfPh0jRozAM888g4EDB+Khhx7C119/3eLX+Prrr2G323HzzTe3aU1bt27Fxo0bMWfOHDz//PP47W9/izVr1mDSpEloaGhodv3dd9+Nffv2YcmSJfjDH/6AWbNmKX93zz33nFKuSktL8/k1bTYbCgsLkZKSAgDYu3cvLrzwQuzatQu///3v8fDDD6OgoACTJk3Cli1bWlz/2rVrMXHiRJjNZjzyyCP4y1/+gurqalxyySX46aeffD4uIiIC11xzDT777DPN9xoAPvvsM1gsFsyZM6fFr00UdoKdWiKitvn2229FvV4v6vV6cfz48eLvf/978ZtvvhGtVqvX659++mkxOjpaKU0dOnRIBCB++umnyjW7du0SAYj33Xef3+sqKysTIyMjxalTp4oOh0O5/Z///KcIQHzttdeU2y666CIRgPjmm28qt1ksFjEzM1OcPXt2i19n4cKFIgBxx44dbVpXQ0NDs9s2bdrU7OsvX75cBCBOmDBBtNvtmutbK2NNnTpVPHPmjHjmzBlx165d4pw5c0QA4r333iuKoiheffXVYmRkpHj06FHlcUVFRWJ8fLw4ceJE5TbPMpbT6RT79esnTps2TSkxya8pLy9PvPTSS1t87d98840IQFyxYoXm9ssuu0zMz8/3+TiWsShcMbND1E1ceuml2LRpE2bOnIldu3bhySefxLRp09CjRw/897//bXb9O++8g8svv1wpTfXr1w9jxozRlLLMZjMAeC1ftdXq1athtVpx//33Q6dzv6XccccdMJlM+PLLLzXXx8XF4aabblI+j4yMxLnnnotjx461+HXau9bo6GjlzzabDRUVFejbty8SExOxffv2Ztffcccd0Ov1bXpu2bfffou0tDSkpaVhxIgR+PDDD3HzzTfjb3/7GxwOB7799ltcffXVyM/PVx6TlZWFX/3qV/jhhx+U1+Rp586dOHz4MH71q1+hoqIC5eXlKC8vR319PSZPnozvvvsOTqfT57ouueQSpKam4oMPPlBuq6qqwqpVq3DDDTe06zUShQO23hN1I+eccw4++eQTWK1W7Nq1C59++imee+45XHvttdi5cycGDx4MANi/fz927NiBW265BUeOHFEeP2nSJCxbtgxmsxkmkwkmkwkAUFtb6/eaTpw4AQAYMGCA5vbIyEjk5+cr98t69uzZrEckKSkJu3fvbvHrtHetjY2NWLp0KZYvX47Tp09rJtFqamqaXZ+Xl9em51UbN24cnnjiCQiCgJiYGAwaNEjpqSopKUFDQ0OzvxcAGDRoEJxOJwoLCzFkyJBm9x8+fBgAMG/ePJ9fu6amBrGxsaisrNTcnpaWBoPBgNmzZ+Pdd9+FxWKB0WjEJ598ApvNxmCHzkoMdoi6ocjISJxzzjk455xz0L9/f8yfPx8ffvghHnnkEQDA22+/DQBYuHAhFi5c2OzxH3/8MebPn4++ffvCYDBgz549XbZ2X9kT0cdYvGzgwIEApL2GRo4c2erXuffee7F8+XLcf//9GD9+PBISEiAIAubMmeM1K6LOBLVVamoqpkyZ0u7HtUZe31NPPeXztcbFxeHHH3/ExRdfrLm9oKAAvXv3xpw5c/DKK6/g66+/xtVXX43//Oc/GDhwIEaMGBHw9RKFOgY7RN3c2LFjAQDFxcUApKDh3XffxcUXX4y777672fV/+tOf8M4772D+/PmIiYnBJZdcgrVr16KwsBA5OTnt/vq5ubkAgIMHD2rKNVarFQUFBQELBmbMmAG9Xo+33367TU3KH330EebNm4dnnnlGua2pqcnnnjnedGRKKS0tDTExMTh48GCz+w4cOACdTufz77tPnz4ApGxWS39/I0aMwKpVqzS3ZWZmAgAmTpyIrKwsfPDBB5gwYQLWrl2LP/7xj/6+HKJujT07RN3EunXrvGY/vvrqKwDuMtKPP/6I48ePY/78+bj22mubfdxwww1Yt24dioqKAACPPPIIRFHEzTffjLq6umbPv23bNrzxxhs+1zVlyhRERkbi+eef16zv1VdfRU1NDS6//PIOvW5ZTk4O7rjjDnz77bded4x2Op145plnlE0F9Xp9s7+vF154oV27QcfGxgJAuwIkmV6vx9SpU/H5559rxtVLS0vx7rvvYsKECUppztOYMWPQp08fPP30016/J2fOnAEglf+mTJmi+YiKigIA6HQ6XHvttVixYgXeeust2O12lrDorMXMDlE3ce+996KhoQHXXHMNBg4cCKvVio0bN+KDDz5QjksApMZkvV7vM8iYOXMm/vjHP+L999/HokWLcP7552PZsmW4++67MXDgQNx8883o168famtrsX79evz3v//FE0884XNdaWlpWLx4MR577DFMnz4dM2fOxMGDB/Hiiy/inHPO0TQjd9QzzzyDo0eP4n/+53/wySef4IorrkBSUhJOnjyJDz/8EAcOHFDGqq+44gq89dZbSEhIwODBg7Fp0yasXr1aGQtvizFjxgAA/vjHP2LOnDmIiIjAlVdeqQRBrXniiSewatUqTJgwAXfffTcMBgNeeeUVWCyWFvcW0ul0+Pe//40ZM2ZgyJAhmD9/Pnr06IHTp09j3bp1MJlMWLFiRatf/4YbbsALL7yARx55BMOGDcOgQYOaXbNixQrs2rULgNTIvXv3buX7PXPmTAwfPrxNr5UopAVxEoyI2uHrr78Wb7vtNnHgwIFiXFycGBkZKfbt21e89957lR2UrVarmJKSIl544YUtPldeXp44atQozW3btm0Tf/WrX4nZ2dliRESEmJSUJE6ePFl84403NCPlvvzzn/8UBw4cKEZERIgZGRniXXfd1Wy354suukgcMmRIs8fOmzdPzM3NbfVriKK0U/K///1v8cILLxQTEhLEiIgIMTc3V5w/f75mLL2qqkqcP3++mJqaKsbFxYnTpk0TDxw4IObm5mrGq+XR861bt3r9en/605/EHj16iDqdTjOG7m0HZW+2b98uTps2TYyLixNjYmLEiy++WNy4caPmGl87KO/YsUOcNWuWmJKSIhqNRjE3N1e8/vrrxTVr1rTp78rpdIo5OTkiAPGJJ57wes28efNEAF4/QmXnbKKOEkSxla5AIiIiom6MPTtEREQU1hjsEBERUVhjsENERERhjcEOERERhTUGO0RERBTWGOwQERFRWOOmgpB2Xi0qKkJ8fHyHtocnIiKiriOKImpra5GdnQ2dznf+hsEOgKKiIr/OBCIiIqLgKywsRM+ePX3ez2AHQHx8PADpL8vXWTVEREQUWsxmM3JycpTf474w2IH7ZGOTycRgh4iIqJtprQWFDcpEREQU1hjsEBERUVhjsENERERhjcEOERERhTUGO0RERBTWGOwQERFRWGOwQ0RERGGNwQ4RERGFNQY7REREFNYY7BAREVFYY7BDREREYY3BDhEREYU1BjtEZ4lGqyPYSyAiCgoGO0RngWdXHcLwx77BrsLqYC+FiKjLMdghOgtsLaiEzSFiz+maYC+FiKjLMdghOguYm2wAgCYbS1lEdPZhsEN0FpCDHYvdGeSVEBF1PQY7RGcBc6MdQOAyO1a7E8+tOoTtJ6sC8nxERJ2JwQ5RmHM6RdQGuIz149Fy/GPNYfzt6wMBeT4ios7EYIcozNVb7XCK0p8bAxTsVDdYAQA1jbaAPB8RUWdisEMU5tQBSZMtMD07Da49e9jwTETdAYMdojAn9+sAgQtOGpVghw3PRBT6GOwQhTl5EgsIXHBSb5GCnUCVxYiIOhODHaIwZ1aVsSz2wAQnDTYpW8Rgh4i6AwY7RGHO3OQuYwXqfKwGV2bHanfCIXc/ExGFKAY7RGFOndlpClRmRxU0sUmZiEIdgx2iMNcZPTuNNlW2iMEOEYU4BjtEYa4zprHkBmUgcKUxIqLOwmCHKMx1SmaHZSwi6kYY7BCFOU3PToACkwaWsYioG2GwQxTmanwEO002B5x+TlI1sIxFRN0Igx2iMKcePbc7RdgdTtQ22XD+X9di3vKf/HpO9TQWMztEFOoY7BCFObPHYZ1NdicKyutRWW/FD0fK/Spt1VsD3/RMRNRZGOwQhTl1gzIgBSd1FilYEUXgSFldu5+zkZkdIupGGOwQhTGnU1QCG1mj1aEZHT9cVtuu57TanbCren0arTwMlIhCG4MdojBWa7FDdMUlMZF6ANL5WPWqAOhQafsyOw1WbfDEMhYRhToGO0RhTO7XMRp0MEVFAJD22lFnew6Xti+z0+AxfcUyFhGFOgY7RGFM7tdJiI5AVIT0495kc2iyM+3P7GiDG2Z2iCjUMdghCmPyURGm6AhERUhlrEabA3Wqnp3CqgY0Wh0orGzAM98eREF5PQApiPnXd0fx311Fmuf0LGNxnx0iCnWGYC+AiDqPnNkxRRngcPXuNNmcmp4deSLrL1/tx6ZjFfi/74/h1xPy8dWeYhwrr0dUhA5XDs+CIAgAWMYiou6HwQ5RGJN3TzZFRyjlpiabtkEZANYeKMOmYxWu+53457ojyn1NNicabQ7EREpvF80yOwx2iCjEsYxFFMbkBmVTlLuMpd5nx6CTsjX/9/0xAMD5fVKwdNYw9EiMxvVje0Lvul99cjp7doiou2FmhyiMyUdFmKINsNql/XCa7O4y1uBsE3afqlGCn+vH5uDqUT1w47m9AADf7itFdYMNtU02ZCZEAfBSxvLSs9NodSDaNeoeCBa7AwadTgm+iIjag5kdojCmzey4prFUmwqOyklUro03GjBtSKbm8fFR0r+H1LswN7gCI1cLT7My1td7ijHkkZV476eTAXkNTTYHJj21Hje8sikgz0dEZx8GO0RhTGlQjvZexhrVK0m59ooRWc2yMfLePOrDRBtcwU1STCQAoNGm3UF5+8kqOEVg9b7SgLyGY2fqUVzThO0nqyCK/p3STkRnNwY7RGFMGT1X9+zY3fvs9EyKRq/kGABSCcuTktlpVGd2pGAnOVYKdpo8yli1rsBoX7E5IK+htLYJAOAUAZuDwQ4RtR97dojCmHZTQTmz41T22Yk1GvDveWNRam7SZHlkcmantql5g7Ic7HiWseRri2uaUFlvVa7zV5m5Sflzo82BSAP/jUZE7cN3DaIwpvTsRBs0OyjLDcpxRgP6Z8Tjwn5pXh8fr5Sx3JmdRpv02NQ478GO+tp9RR3P7pSZLcqfOflFRP5gsEMUxuQsi7qM1WB1KAFKrLHl5K4p2qB5HgBKc7NSxvKR2QGAfcU1HVk+AHcZy9vXIiJqCwY7RGFMzuzERxkQ5Sr/VNRblftjWhkPVzI76p4dVxkrJdYIwFuw4752bwAyO6WqzA43MCQifzDYIQpjDaoMjjxpVVEnBQ8GnQBjK/0vpqjmmR25jJXiKmPZHCJsDvdEliazE5Aylqpnh+dwEZEfGOwQhSmHU4TDKU0vReh1Shmrok7K7MQaDcp5V76YvPTseJaxAG12p051FMXRM3UdLj2V1ap7dpwtXElE5B2DHaIwpc62RBp0MBpcwU69FDzEtdKvA3jv2ZGzK4nRkdB5bCxodziVMpfRoINTBA6U1Pr9GpxO0SPYYWaHiNqPwQ5RmLLYVcGOXqdMY8l71cQaWz/OIV4ZPVdldlx79MQY9YiWx9mt0tdSZ3VGu0bZO1LKqqi3KtkpgD07ROQfBjtEYcqqCnYi9IJSxpK1NokFqMpYjc0zO7GR7j4gOQiRM0BRETqMcB1F0ZGJrFJVvw7AzA4R+YfBDlGYkstYkXodBEFQsjCytpSx4pUG5ebTWDGReiWAkoMdubcnPioCg7NNADqW2TmjKmGpvw4RUXtwB2WiMCVnduQdh5tldiLb0rMjZXbqrQ7YHU7oBEEJOKLVwY5Vm9mJjzIox1CoR8fbyzOzw2ksIvIHMztEYcrqyuxE6KUuYrlnRxbTpp4dd0BUZ7FrMiuxkQZ3z45HGSveaFDG1mtUe/S0l2egpO5DYuBDRG0V1GBn6dKlOOeccxAfH4/09HRcffXVOHjwoOaapqYmLFiwACkpKYiLi8Ps2bNRWqo9TfnkyZO4/PLLERMTg/T0dDz44IOw2+0gOpu1ltlpSxkrQq9TAhpzo11pThYEKXiK9ihj1VncZawEV1aozmKH3eHfyLh692TAHeC8/9NJDHlkJb7ZW+LX8xLR2SWowc6GDRuwYMECbN68GatWrYLNZsPUqVNRX1+vXLNw4UKsWLECH374ITZs2ICioiLMmjVLud/hcODyyy+H1WrFxo0b8cYbb+D111/HkiVLgvGSiEKGnNlRgh1D+xuUAdXJ5002JdiIidBDEARERfouY8klMPXt7SWfiyVnieSg6ucTVXCKwE8FlX49r79e/7EAX+0p7tKvSUQdF9SenZUrV2o+f/3115Geno5t27Zh4sSJqKmpwauvvop3330Xl1xyCQBg+fLlGDRoEDZv3ozzzjsP3377Lfbt24fVq1cjIyMDI0eOxJ/+9Cc89NBDePTRRxEZ2bETl4m6KzmzE6F3BTuR2n/btCWzA0h9O2W1FpibbNC7NtaJdvX7RLtKY57TWPFRBkTodYiN1KPe6kBNow1Jfpx+XubK7PROjcXuUzVKuUw+yNSzgbkz7S8249EV+xBvNOCyYVld9nXby+EUIQDQ6VreMJLobBJSPTs1NdKIanJyMgBg27ZtsNlsmDJlinLNwIED0atXL2zatAkAsGnTJgwbNgwZGRnKNdOmTYPZbMbevXu9fh2LxQKz2az5IAo36mks+b/qDZNjWzkXSxavOjKiQd5jx/VYz54d9TQWAKWU5W/fjtygLDc7u8tlXR/sbDxaAQCotdhDtl/o6Jk6DHp4Jf72zYFgL4UopIRMsON0OnH//ffjggsuwNChQwEAJSUliIyMRGJioubajIwMlJSUKNeoAx35fvk+b5YuXYqEhATlIycnJ8Cvhij45MyOfP6VIAiaUlZby1gm1WGg6rFzAMo+O80alF0BkqkDwY7DKSrBTO+UWM3XUTI7dV0X7Gw+VqH8Wd6F2psPtp7EZztOd8WSmvn5eCWsDife3XxSs88S0dkuZIKdBQsW4JdffsH777/f6V9r8eLFqKmpUT4KCws7/WsSdTXPMhagnchqaxlLm9nRBjue++y4gx0pyJGDHfXZWm1VUW+BUwR0AtAzKRqA+2wseR1lHqPpncXpFDX9QVX13l+PucmGP3yyBw9+tAsWe9dnf6obpHXVWuzYerxr+5mIQllIBDv33HMPvvjiC6xbtw49e/ZUbs/MzITVakV1dbXm+tLSUmRmZirXeE5nyZ/L13gyGo0wmUyaD6Jw49mgDGgnstqc2VEFLHIZS36sMo3lOi6iViljSfd3pIwlNyenxRsR4/p6cvlILmOZm+xdsqvyvmKz5jVUNli9Xlddb4MoSkdyyIFHV1KvcfX+0hauJDq7BDXYEUUR99xzDz799FOsXbsWeXl5mvvHjBmDiIgIrFmzRrnt4MGDOHnyJMaPHw8AGD9+PPbs2YOysjLlmlWrVsFkMmHw4MFd80KIQpDn6DkAzS7KbTkbC/Ce2ZGfx3P0XM7smAIQ7Mj9OunxUc2+Tr3qDK7yLihlqUtYAFDpo4ylzmBV1nsPiDpTtUewI4piC1cTnT2COo21YMECvPvuu/j8888RHx+v9NgkJCQgOjoaCQkJuP3227Fo0SIkJyfDZDLh3nvvxfjx43HeeecBAKZOnYrBgwfj5ptvxpNPPomSkhL8v//3/7BgwQIYjcZgvjyioHJvKugOdoz+ZHbUPTuWlnt26lzBTpzRd4Nyo9WhPK4lcr9OWryxWSN0vcWhua5nUkybXou/mgc73oM39Yh9lY/sT2dS/z0XVjbicFkd+mfEd/k6iEJNUDM7L730EmpqajBp0iRkZWUpHx988IFyzXPPPYcrrrgCs2fPxsSJE5GZmYlPPvlEuV+v1+OLL76AXq/H+PHjcdNNN+GWW27B448/HoyXRBQybF4yO+qenbYcFwG4szSanh1XoNT8uAjvZSyz65fwU98cwPDHvsGeU60fDipnSRKjI5R1N9kcsNqdSiAHdP5ElsMpYourX2dUr0QAQJWPrI36DLGglLFcX9PgGjtnKYtIEtTMTltSrFFRUVi2bBmWLVvm85rc3Fx89dVXgVwaUbcnBwRGdYOyahqrPfvsAECtxYYGm2v0vJUyljKN5XFkxMajFbA5ROworMKwngktfl31c6kbodUlLKDzJ7L2FZlR22RHvNGAC/umYsfJalT4DHa6NrPz3aEz+KWoBndd1AeCIKC6UfqakwakYfX+MqzeV4q7J/Xt9HUQhbqQaFAmosBrbRqr3TsoN9pRVC310cgZG3UQ4nSKqLNqp7ESYiKUxwLupmNf00xqcjbIFB2hlL0arQ6lOVlW1oGDRtti16lqAMDo3CSkxUulcV+ZHfXafF0TSIs/2YMnVx7EL6elvcLkoPKqkT0AADsKqzmCTgQGO0Rhy+qQMqeaBmVX0BCp12lub4ncs1NZb8WGg9IgwPg+Ka7nc5eX6qx2yMlab9NYTqeo7IjclqyHt8xOk92plNJknZ3ZUW9sKO8C7av5WF3GqurkMpbN4URRTSMAoNj1X7l0NijLhAi9AFHs2r2IiEIVgx2iMOVtGksuY7V1EgtwZ2lOVzfC3GRHcmwkRvVKkp5P1bMjByeRep1yuzrYqWqwwuYKwNoS7Kh3Y5bLZVa7UxNQAJ3fs+OeCjMiWQ52fKy/K8tYJTVNSnBZUW+FwykqXz8pJgLp8VEA3OsnOpsx2CEKU97KWPI0Vkwbm5MBwBStvfbiAenuM7JUZSzP5mRAG+yUqYKStmQ9zMoYe4RmZL68ThtEdH6wIz1/hilKCXZ8lajMTV1XxiqqblT+XF5rUcp+gFT6yzBJJbeu2niRKJQx2CEKUzavmwpKf25rczLgzuzIpgxKV/6sHj2v82hOBlRj6002lNS4f+lWt7OMZVS9BnlfHfnMr84OduQgLd1kRHKMK9hpsMLpbD5g0ZVlLLmEBUh/J3K/TpxROoTVndlhGYuIwQ5RmPI8Gwtwl53aU8aKjdRDPkA7Uq/Dhf3TlPuivZSx1MGRPMklitIhlbI2lbFUDco6naC8DjnY6ZUi7a1zptbSqZvnyZmRDFOU0rPjFKVs1cmKBjy58oCyJnUZqy0BXVscKq3FU98caHbkhtwsDkjZLnlDQTmbpmR2apnZIWKwQxSm3JsKuo86j1aCnbZndgRBUAKY8/qkaLJC6jKW2UsZKypCrwQph0tVwU4bprE8y2JyFqnCVcaSDwe1OpzKtFegWe1OZcw8Pd6ICL1OWU9lgxX/XHcYL64/ig+2FmrWDGibmDtySvo/Vh/GsnVH8d+dRZrb1WWsM3UWJbiSg510EzM7RDIGO0RhSjkby8voeXvKWIC7b0ddwgKAKFcA4hTd5STP55Z/+R4uq1Vuq7PYWxyJdjpF1FrcPTuAu7lazqIkx0Yo+/icqeuc7IU8yRShF5DkKmGlqCay9hdLr0ku0akzO+YmO+wOJz7feRpDHlmJT7af8msNJa7Mkjq48fy8QlXGcmd22KBMJGOwQxSm3NNY7pLVhL5pyE2JwfSh3g/J9eX6MTkYmZOIK4dna26PNxqQlSD9Uv3vLinz4NnjowQ7qswOAGUDPG/qvYyxe2Z2Yo0GZd+bMj/7do6dqcPSr/ZrSmwbDp3Bez+dBKA9n0vnquXJpayKOguOlEmPk7M46mAHkEpd3x0qh1OUNlT0h/zcnhma4hptGUsOdhJjPMpYzOwQBXcHZSLqPO5pLHcZa3C2CRsevLjdz3Xv5H64d3K/ZrcLgoBZo3tg2bqj2O06AkJdxgLUOzBrA4GqepvSROtJnmqKNLjH2JWeHdchnLGRUrBz9Ex9u5uUHU4Rr/1QgKe/PQiL3YnimiY8f+MoOJwi7nlnO2otdozJTVIChXST+5w9uUl596kaZedod8+OtjxX1WDFycp6AM0zM20lP7dn781p1fPVNNpQ7vo7kIMdpUGZPTtEzOwQhStv01id4doxOZrPTVHey1ieWmpSloMG9XPJmR35l3qs0aD8Qm9vsPP31Yfw56/2w+IKCH8pkgK14xX1SlC2v9isBBgZqqBMHj+Xz8sCpOyLwymi3tWbE+8q5VU12HC8ogGAf8GOtK+QdvdpQJpuk2+Xm8ePlktBlcmjQbm6wQaL3f+eIaJwwGCHKEx5m8bqDHmpsTind5Lyua8ylqxHYjSAlqeV5IZj9XPJzdBm5WR1vVLGam+wI5eU5o3PBQAUlNejwWrHviKzcs2h0lp3GUud2XEFO7sKq5XbKuutmqMicpKlSbGi6kZlbUU1Te2eGlM3OaszNMWuSazEmAikxklrO+oqqSVGS+tLiI5QAl2Wsuhsx2CHKEy5p7E6/8f82jE9lT97lrHUwY4gAP0y4gAAlS1MZHnL7ERFaMfl1T077Q125P6WaUMykR5vhCgC+4trsVcT7NRpNhSUyT07dtU+O5UNVmVUPtKgQ6arj2lXoft0d/VkV1tV1LtfV3WDDU2uspm8x052QrQS7BxzZXbkv29BEDh+TuTCYIcoTHk7LqKzXD48W8m8eGZ2TKpgJyXWiDTXL+eWyljqoyJk0d6CnTj/GpTVe/gMyTYBAPYVm7Gv2B3sHFZnduKbZ3bURBE4WSmVq+KNBqVvRj5EVNbeUlaFj92i5efJToxGSpy0Hvn7LX9twF1+4/g5ne0Y7BCFKW+j550lzmjA/VP6YWBmvHJIqEyd2ckwGZXMSEtlLLkfRX1UhWdmJ85oQK5rY0F5Kqqt1GPag+Vgp8isKWOdqGxAoSuAUWd25AZlT8crpMxKfJRBGVP/5XSN5pr2BjueB47KGRp3sBOlBHwy9d+3XH7j+Dmd7RjsEIUpZRqrCzI7APCbi/pg5f0Tm2U+1KWo9HijknloqYwlZ17ije5f3PIeQbJYowEDs0wQBGkvmoo2nu7dZHMojcmm6AgMzkoAAHx36AzK6yzQCVJ2RhShNBdrenbi3K8v0qBDXqq0ueEJ17XxURFIcr1Gi8deQupdj9ui3OM1yRka+XmyE6ORGt9CsOPK7Pg7mk8ULhjsEIUpWxdmdlqizexEKZmR9mZ2PMtYcUY94owGZSdleYO/1siBlOAKauTMjjzKnZ8Wh0FZJs1jNNNYqsxOn7Q4JbNSUK7K7HgEfHLw09HMTqnZM7MTjdQ47dfSlLG4sSARAAY7RGGrq6axWqMtq0QhUXWYpi9mL+dsyaPnMvnIi8GuwGRvkbZk5ItcwjJFSWdu5SbHIFb13IOzTEoTNSAFi+oAQh3I9M+IU3pmTngpY8nOy5dKe+rDO9vCs2enTJnskp6nR2IUUmJ9Z3a4sSCRhMEOUZhybyoY5GAnxqNnx/V5S6eCm9s4jQXA3XOjai5uifzcclCg0wmaTM7gbBP6Z8Qrn6ebjBAE98aMpigDDK7NbfpnxCtlO3UZSx0cAVD6mE63s4wlT2/1co2yl5qb4HCKyvEUWQnaMpZeJ2iO62Bmh0jCYIcoTNkc0mh0V0xjtcSzh0QODlreVLB5Zscz2IlxfS4HO+qx8ZZ4niGlfg4AGJKtzeyke/TECIKgZHf6pcchxVXGkvtz4qMMmr4lo0GHkTmJAIDi9k5juUbPB2VJwVeZ2YIztRbYHCL0OgHp8UZNGSshOkITmMlrZ7BDZzsGO0RhSBRF9zRWkIMdU5Q2syOXsWoabXA4vW+ypzQoR3nv2YmK0MHgylgNcWVljp2pa9Pp4koZS9UPNFid2cnSZnbUk1iyWaN6YGBmPM7rk6IcDCqTGpTdt/VKjlE2UiyrtbRrN2O5Z0fOPJWam7CzsAoA0CctFga9TjONleixgaN88rm5ya7s0UN0NmKwQxSG5EAHCH4ZKyZSj8SYCBh0AnomxSglHlF0Bx6elE0Fo71PY6lLNWmu7IZTBA6Wtt6kXNPQPLMzOjcJgiDtBp0SZ0RqnFHJzngLdhZfNggr758IU1SE0rMjM0UZNGWs3JQYJMdGKr1TpTXu/hlRFNFg1Z4Z5nCKcLqCQLlnRw7Gymot2OTa/Xm8qw9I3UNk8gh2TFEG5e+NfTt0NmOwQxSG5BIWEPwGZUEQsPzWc7B8/jlIjo1EhF6nZGx8lbLcDcreMzuxqmBHEAQMzpbGx9vSpFzjOopCHez0z4jHm7edi/+7ZYxyW790qZSlHjv3xnPUPs5ogNGgV5qec1NiIQgCsl3ZHXWT8p+/3I8Rj32rrLuizoJz/rwaC97djiabQzmCQs7s1DTasP7QGQDupucIvU7pg/LsFZJ2UZaCtQMlbSvzEYUjBjtEYchqD53MDgCM6pWEC/ulKZ8ntTJ+7j4uQpXZUU1MxUZqj6SQMx/qTQGr6q145tuDzfpVahqbZ40A4MJ+aeib7i5fXT82B72SYzCpf3qLry3VY1M/uc9ILtfJGx9mJ0pBh3r8fP2hM7A5RKw/KAUwm45VoLLeim/2luBUlXSdlBGLVjI0ciP0uHz35o3yGrwdunphv1QAwMOf/9LmvYiIwk3w3wWJKODkYEevE6DXCa1c3fWSWthY0Gp3osnm2vRPHewY3MGOuowFeG9Sfvrbg3hh7RG8vOGo5lrPaSxfZo/pie9+f7Gmedkbz8yOnI3qmSRlcga4+n+yE1yZHVewY3c4lXF1eZJMDtacIrDBlcFJjo3UZGgAYGBmvObrysGOZ88OACyeMQh90mJRarZg4X92KSUyorMJgx2iMBQqGwr6ktTCRJac1QGAOHUZS53ZMWons+TzrQ6UmGG1OyGKIlbvLwUAHD1Tr7nW2zRWRyTFREI1AKUEO3+bPRzP3zgK5+YlA4BSxpLHz09VNSrlRjnIUQdra1zrl6e91BsbnpevPZJD7hvy9ppijQa8OHcMoiJ0+O7QGSx4d3uznZmJwl1ovhMSUYdYuvAQUH+0VMaS+3XijAZNVspXzw4A5KXEIj3eiCabE2sPlOKX02blaIWTFd6DHVNUYIIdvU7QTF/JZazeqbGYOSJbGQWXy1jFrp4decdlQDpXq85i1+wV9FNBJQAo015pqt4hz2DniuFZyEmOxsUDvZfcBmTG42+zh0OvE/D1LyWY+tx3+PFIuX8vmKgbCs13QiLqkFDZUNAXb+dj2RxOWOwOVb+ONqDxNY0FSBsDXjO6BwDgo22nlKwOIGVQ7KrpNHOAMzuAtpTluW5ZzySpd0cOco6ecR9eKorAD4fPKKeaA4DdVW6SszZyZkcQgHGubJFs+tAsfP/7SzCqV5LPNV41sgc+X3ABBmWZUFlvxR8+2Q1RZEmLzg6h+U5IRB0il7GCPYnli3y+VEG59Au/0erAtS9txPila3HsjHzsgjYYaSmzAwDXjckBAKw7eAaf7Tyt3G53iiiucTcpB7qMBUCz147numVyqe1ERQOq6q04Vq7NOH207RQAoEditCaj5R6BlzI7AzNNzc7eaquhPRLw8V3jYTToUFjZiEOl7Tstnqi7Cs13QiLqkFDZUNCX8/tKZZhv9pZixa4iLPn8F+w6VYPKeite33gcgHbTP8BzGkvbswMAfdPjMKpXIhxOEScqGiAI0h48gHuCCeiczI6cfTHohGans8sSYyKR7zohfeepahS4gjp5w8F1romsUb0SNZsays3H04Zkok9aLO6cmNehtcZEGjChrzShpc6AEYWz0HwnJKIOcZexQm8SCwDG5CZjwcV9AAC/+88ufOjKagDAzsJqAM0zJOppLG+ZHcCd3QGA0b2SMLyHtP/OcVffjs3hRL1rl+XAZnaMrjUbNMc1eJKPjdhxshrHXFmtK4ZnAYCym/SQ7ASM6pWoem4pkOqdGos1v5uEa0b17PB6Jw/KAMBgh84eDHaIwlCoZ3YAYOGU/hiXl6ys9TcT8zVZkXiP3pcIvXuM3lewc8WILOU5Jg9KRy/XHjcnK6XMjlm1Y7Pn83eEXGryVcKSyUHMxiPlSgP15a5gRzY426QERernDqTJg6RG5p2F1Zo+IaJwFbrvhETkNzmzE6qj5wBg0Ovw/I2jMKpXIm4Ym4OHpg/EjKHuX/ye01KCICh9O54NyurH3HNxXwzMjMfs0T2R6zotXN7PRu7XiTMalLO1AkE+jNPXumQjc6QG4p9PVCmPG5qdoHnc4CwTRqmCnZS4lndw9keGKQrDeyZAFIF1B8oC/vxEoSZ03wmJyG+hPo0lyzBF4dO7L8Dfrh0OnU7AtWPcJRpvmRc5a+MrswMA91zSDyvvn4gMUxRyU6QeGblnpzOakwEgJ1m7S7IvA7PiNU3jeamx0OkE5VTz9Hgj0uKN6JMWh5RYaf8euacn0CYPZCmLzh6h/U5IRH6xdYMyljfj81OUX+7eSkJRrsyO56aCvqjLWKIo+jwqoqMm9kvDP+aMxKMzh7R4XYReh2GuPiIAyE+Vzt+Sj7uQd2vW6QS8cdu5eG3eOchMaDmA8pdcyvr+cHm7TmIn6o661zshEbWJnNkJ1dFzX3Q6Ab+fPgB5qbG4dHDzDfKuGpmNgZnxGN4zsU3P1zMpGoIANFgdKK+zKhsWJkQHrl8HkNZ91cgeyl46LVH34+SnSZmn68bmID81FnPH5Sr3De2R4HOTwEAYkm2CKcqARptDGfcnCleB/YknopAgN/2GehnLm6tG9sBVI3t4ve/BaQPx4LSBbX4uo0GP7IRonK5uxMnK+k4rY7XHSNWkVZ5rFH1ojwSsfWBSl65DEAT0z4jHzyeqcKi0VjlZnSgcdb93QiJqlTXEj4voSvKp48fLGzplj532Uu9ynJ8WF7R1AEA/134+h7m5IIU5ZnaIwpA1xA8C7Uq5KTHYeLQCJyob0GSTelMCdS6WP7ITonDNqB6obbIrmZ1g6ZcuBVuHSmuDug6izsZghygMKdNYzOygV7IUUJysqIfRtTFhMDM7giDguRtGBu3rq8k7NR8ua57ZsTmcMOiEFjdJJOou+E5IFIZszOwo5DLWodI6mF2HjCbEBC/YCSX9M6TMzomKeiXrBQAlNU0Y95c1uOfdHcFaGlFA8Z2QKAx112mszjAmNwkRegH7is3YUlAJILiZnVCSFm9EQnQEnKL2FPYvdhehst6Kb/aWaIIgou6K74REYai7bCrYFTJMUbh+rHRmVmW9FUDg99nprqSJLCm7o25SXrNf2lXZ7hTxy+maZo9rsNohimKz20VRZHBEIYnvhERhyOqQfhFxGkuy4OK+mpIeMztu8kSW3KRc02DDT8crlfvlg1lln+88jWGPfounvjnY7Ln+7/tjGLxkJb7eU9x5CybyA98JicIQR8+1shOjccM57hPRgzmNFWr6KxNZUmZn/aEy5QR2QDqhXXaotBZ/+HgPHE4R//6+AEXVjcp9docT//d9AZwisPTrA0rfGFEo4DshURjqzpsKdpa7L+4Do0GHSIMOafGBP1yzu3JPZEmZHbmENcK107Oc2am32HH3O9vRaHNAEKT/x15cf0R5nu8On1FOUD9Z2YBPt5/uoldA1Dq+ExKFIRszO81kJUTjo9+ej7dvH8cylopcxjpZ2YDaJhvWHZSCnUWX9ocgAKerG1FmbsJfvz6AI2V1SI834oUbRwEAPthaqGR3Pvz5FAAgwyQFki+sO8zsDoUMvhMSdQOnqxvx5MoDKDM3tel6ObNjZGZHY1jPBJyblxzsZYSU1LhIJMVEQBSB37y1DbVNdiTHRmJC31T0T5cCoRW7i/HeTycBAM9ePxJXDM/GefnJsDlEPP3tQVTUWZTT01+cOwapcUYUVjbi422ngva6iNT4TkjUDby16QReXH8U72w52abr3ZsKckM4apkgCBjmOlh149EKAMClgzKg1wnKoaVPrjwAu1PEhL6pmNAvFQCwcEp/AMAn209jxj++h80hYki2CWNyk3DnxDwAwOc7i5SvI4qiphfIG1EU0Wjt/tNcTien0kINgx2ibqDeIp3WXdVgbdP17uMi9J22Jgoff756KP542SA8NH0gllwxGA/NkA5bHeU6tNTiCp4XXtpPecy4/BQsnTUMMZF6lLl6da4b0xMAMLa3lD07XuE+Tf2hj3dj1OPf4rSqqdnTYyv2YcTj3+JwNz++4tbXt+L8v65VNrGk4ONxEUTdgMO1p0ldk71N13Mai9ojJzkGd0zMb3a7+oT2C/ulYkyutgR447m9MKFvKh5bsQ9VDVZcM1oKdnKTpV2rS8xNaLI5EBWhx7f7SmFusmPtgTLcfF6u13X8cKQcVrsTP5+oUnqJuhuL3YEfDp+BUwSOlNVhtOrgVwoeBjtE3YDDtW9OraV9wU6EnmUs8l+/9Hgkx0aist6K+11lK085yTH497yxmtuSYyMRZzSgzmLHqaoGJMcaUd0gZTl2nqz2GuyIoqg0Oxe1kP0JdScrGiBX62oamNkJFQx2iLqB9mZ2lLOxmNmhDtDrBLx527moabRhTG7bMxSCIKBXcgz2FZtxoqJBCXQAYGdhldfH1DTa0ODq12mp1BXqjp5xl+6qG9tWdqbOx2CHqBuQGzvr2prZcfBsLAqMoT0S/Hpc71R3sBMX5f5Vc/RMPWoabM0OY1UHON05s1NQ7g52quqZ2QkVfCck6gbsrmCnvt1lLP6IU3D0So4FIO3fc0yV7QCAXaeqm11fXO3eVqG4pm1bLISiY6oDVasbGeyECr4TEnUDTmf7enZYxqJgy02RmpRPVNQrAYBeJ/WQeZ63BQBFNe5sTnF1k/L/fHdzTJXZqW7j9CR1Pr4TEnUDdqcUvLS1Z0ceFY5kZoeCRJ7IOlHZoJR2Jrr26PEW7KjLWFaHE+X1lhafv6bBhidXHsCRstAaUy/QBDvM7IQKvhMSdQNyz06jzQF7G7bgZxmLgq2XK7NTWNmAExUNAIBZrtH0nYXVEEVt5kZdxvL2uadPdpzCi+uP4vk1R1q8ritVN1hRWe/O5rCMFTr4TkjUDah3nq23tL4zq40NyhRkWQnRiNALsDlEWB1ORBp0uHRwBiL1OlTWW3GyskFzvWdTcmtNyvLjPZ8nmI569CaxjBU6+E5I1A3YVcFOnbXlUpbd4VT2+WDPDgWLXicgx1XKAoC8lFhERegxKNsEoHkpSw5ueiZFA2h9/DwU9+SRS1gxkdLO5SxjhQ6+ExJ1A05Vyr+1vh2rqszFMhYFU6462EmVprNGuc7b2n2qRrnP7nCixHXI7TmuoyaKWiljyfeX1VpgsYfGOVRyI/YI11ljbT3ehTof3wmJugG7QxXsWFr+16LN7r6WmR0KptyUWOXP+WnSnwdkSsdAHFKdf1VWa4FTlHb8Huba16e4pm2ZHQAorWm5mbmryCP28gaMtU32NvXYUefjOyFRN6Du2altJbNjcUj/yhUEwKDjcREUPL1UmZ38tDgAQP8M6b+HS9370ciBS2ZClFLGaqk81WRzoELVCFzUSmDUVY6VS69plOpMMXMbJyg705GyWjy58gBqOqFh+svdxfjw58KAP2+gcQdlom7AoS5jtbLXjnoSSxAY7FDwyHvtAO4yVt90KbNTYm5CTaMNCdERSn9OdkI0shPlnh2pTNVkc8Bo0P6/7LnpYCj07TicIo67ps76pccj3mhArcWOqgYrkmMjg7q2F9Yewec7i5AaZ8RtE/IC9rxF1Y24573tEEVgdG4S+rgC2lAU1MzOd999hyuvvBLZ2dkQBAGfffaZ5v5bb70VgiBoPqZPn665prKyEnPnzoXJZEJiYiJuv/121NXVgSicaKexWg52bK6Sl5H9OhRk6mCnj6uMlRAdgUxTFADpVHDAHbxkJ7qDnfI6Cw6UmHHe0jW4570dmudt7+RWVygor4fV7kSkXoceSdFIjJWOwwiFJuUztVKZT848BcqnO05D/nfY6n2lAX3uQAvqu2F9fT1GjBiBZcuW+bxm+vTpKC4uVj7ee+89zf1z587F3r17sWrVKnzxxRf47rvvcOedd3b20om6VHvKWHJmh/06FGx5qXEYn5+Cy4dlITHGnd3op5SypL4dOVjJToxCUkwEoiKk/3cXf7IH1Q02rNpXqul98ZzUOt1KM3NXePWHAgDAuPxk6HUCEqOl19uR8fNtJyrx7KpDylYS/pIDLnm/I3+Vmpvw5MoDKKxsgCiKmvLVmv1lHXruzhbUMtaMGTMwY8aMFq8xGo3IzMz0et/+/fuxcuVKbN26FWPHjgUAvPDCC7jsssvw9NNPIzs7O+BrJgoGdbDTnjIWUTDpdQLeu/O8Zrf3z4jH94fLccjVt+MOdqIhCAKyE6Nx7Ew9dpysBiD9P32svB79M6QSmLzhoNGgg8XubLGZucFqR3SEvlNLuoWVDcov/nsv6QcASIzpeGbn8RX7sOtUDYZkmzBtiPffg20hB1wd3ZPoX98dw6s/FODbfaV4+IrBOF7RoHwPfj5Riap6K5KCXLLzJeTfDdevX4/09HQMGDAAd911FyoqKpT7Nm3ahMTERCXQAYApU6ZAp9Nhy5YtPp/TYrHAbDZrPohCmWafnTaOnjOzQ6FKaVJ2HfUgZ2bkElYP13/V9ha5R9Xl4GiEa4zdWxmr0erAE1/sw9BHvsFT3xwM3OK9WLbuCOxOERf0TcG5edLovJzJ6sguynIPkFzu85e8htNVjR2aDttzukZZz2/f2gYAmDkiGwMz4+EUgXUHQze7E9LvhtOnT8ebb76JNWvW4G9/+xs2bNiAGTNmwOGaNikpKUF6errmMQaDAcnJySgpKfH5vEuXLkVCQoLykZOT06mvg6ijnO3I7DTZpJ8PuRRAFGr6ZWjHz+XMTHaCFORkJUQp145zBQ/7itz/KJWnr8a6RrxPVzVqjp84XFqLGf/4Dv/+oQBOEfipoNLnWmwOJ55ddQjbTvi+piWFlQ34aNspAMDCKf2V2xOj5cyOf2Usc5NNmZ7yPDW+PSx2Bxqs0nuC3Skq+xP9Z2sh1uxve5+NKIrYr/oeNLreZ64bm4NLB2cACO1SVki/G86ZMwczZ87EsGHDcPXVV+OLL77A1q1bsX79+g497+LFi1FTU6N8FBaG/tgcnd3UmZ3WTj6X39hiIjlsSaGpX7qU2Sk1W7DxSDmqG2zQCUAP19i5XK66bFgmZo3uAQDYV+z+RSv37IztLQU79VaHZsT7kf/uxfGKBkRHSDsZq8fUPa38pQTPrzmMpV8d8Ou1fLO3BHaniPPykzHWtSEiACR1sIx1qtKdrepIY3GNx9c/UVmPI2W1+P3Hu7Hg3e1K2dsbh1NUSuiFlY2otdgRqdcpQV1+aizO6Z2EyYOkYGfDoTOa52uyOZqdgRYsIR3seMrPz0dqaiqOHJEOfsvMzERZmTaStNvtqKys9NnnA0h9QCaTSfNBFMraM43V4DpOQt6ynijUxEdFINuVvXnwo90AgKtG9kCcUQrQ547LxXM3jMBT147AkGxpk8G9RWaIoghRFJWyVZ+0OCWokLNDp6oasPGo1O7w4k2jAQAVdb43Hdx2ogqANP3lDzmQGpSl/T2S0MEy1qkqd3/NsTP1fgcNVR7BzvGKBuU1N9mcOHrGeyBlsTtw6XMbcMULP8DucGJfsVTC6p8Zh3sv6YsX547Gv+eNhSAIGN4jAWnxRtRZ7Fi5V6qq7CsyY9xf1uD2N372a92B1q2CnVOnTqGiogJZWVkAgPHjx6O6uhrbtm1Trlm7di2cTifGjRsXrGUSBZyjHT077swOgx0KXXIp63R1I3QCcO8lfZX7oiP1uGZUT8QaDeibHgeDTkB1gw3FNU2obrChySZlDzITopQ+HzkA+njbaQDA+X1SlKMpzE12nxkM+Ywufzfcq3IFO8kx2sZcd2an5TLW6epGPPPtwWYB2akqd2anptHWLGhpK8+vf7KiXnMumbo8qLbzZDWOnanH/mIztp2owl7XdUOyEqDTCbhsWJayUaROJ+D6sdKJ9g9/9gsOlJix4N3tqGm0Yd3BspA4EDWowU5dXR127tyJnTt3AgAKCgqwc+dOnDx5EnV1dXjwwQexefNmHD9+HGvWrMFVV12Fvn37Ytq0aQCAQYMGYfr06bjjjjvw008/4ccff8Q999yDOXPmcBKLwoq9HT07LGNRdyA3KQPA1SN7KL84PUVF6NHXVfbaV2RWSlipcUYYDXrNJoROp4iPtkttCdeN7QlTVAT0rl3EvZ1TZbE7lF/2NY02TW9cW8nPm+gxhdTWaawX1x3BC2uPYMnnezW3F1ZpJ6eO+cjAANp/DHnyzCydqGhQptwAKEGMp03H3MNAaw6UKX9Pg7O9V0Lum9wfI3ISUdNow8wXflQORRVFYEsLPVNdJajBzs8//4xRo0Zh1KhRAIBFixZh1KhRWLJkCfR6PXbv3o2ZM2eif//+uP322zFmzBh8//33MBqNynO88847GDhwICZPnozLLrsMEyZMwL/+9a9gvSSiTqE+CLS1fXYaLCxjUeiTMzt6nYB7J/dr8Vr5F+zeIrOSwemRGOX6rzuz89PxShRWNiLOaMD0IVnQ6QQkuTIuFXXNg539xbXK9KJTbL0fzhs54yJncmTyNFZrh4HKx2Z8uacYB0rcgYc6swP4blJ+dtUhDF6yEr+crvF6v5xVkaczD5TUas4lk8tTnjargp3V+0qVnilfwU6kQYd/3jgKCdERsDqcMOgEpYFc/VzBEtR/+k2aNKnFOuQ333zT6nMkJyfj3XffDeSyiEKOely01cyOjZkdCn2XDEzHgIx4zBiWqRwl4cvgLBM+wWnsK65BQrT0/7Wc0cl2BT2nqxrx1uYTAIArhmch2hXsp8ZForzOgor65j05O09WaT43u46vaA9fZSx5GkvdINxkc+D1jcfRIzEaV46Qqg/q5uN/rD6Ml24aA8Ad7OQkR6OwshHHyr0HO+sPlsFid2LFriIM7ZEAURTx1uYTyE+Nw4R+qUpmaXCWCTsLq5W9dgw6AXaniH2uXij1PkRNNge2u7I/ggDN1/bsTVLLSY7BCzeOwmMr9uI3F/VBbKQBP5+owqajZ3mwQ0Rt49mg7PnmpNbInh3qBlLjjPhm4cQ2XStnE345bUZqnJTZz1LG1KX/rthdpBxdcP057u1E5HOpKr1MZO1Q9a4AUskpJ7nZZS2SMzuJzXp2pM9rLXbYHE7sKqzG7z/ajWPl9Yg06DB1SAaabE6UuzJOggB8/UsJ9hWZMTjbpDQoT+yXhne2nPRZxipxHbUhl502Ha3Aks/3IishCpsWT1bWN7SHCbtPVUN+K5k0IB0bDpXB3GTHqapG5KgObd1xshpWuxPp8Ub0z4jHD0fKAQC9U2KUJnJfJvZPw5rfTQLgbvo+UFIb9A0Hu1WDMtHZSn0QqN0pwtLCuKg8rRXNYIfCxJAsaSLrdHUj3tlyEoA7oyNneERR2lvqT1cNweheScpjU1zBUbmXMtZOj2CnvU3KoigqZaKkWG1GyBQdAfnfI1/tKcZ1r2xSMiRWuxOHS+uUvpYMkxGXD5MGb15cfwQ1jTalXH1hvzQA8JrZsTmcOOMKKH45XQNzkw2rXHvnFNc0ocnmQE2jtL70+CglMASAc/OS0M91KKt6rB9wl53Oy0/BlEHuvex8lbB8SY0zKtsMBLtvh8EOUTfg2YDYUt+OXMaKZbBDYSIhJgJXj8yG0aCD0aBDdkIUJg2QfgkPyTZhWI8ETOyfhpX3TcTN43trHpuiZHa0ZazKeqtyVtTATOmXfnVj+6aGai12ZXggySOzo9cJMEVJAdATX+6HKAJTB2couz7vKzIr2Zq81Fj8ZmIfANLGfPKOyalxkRjiCjBOVNQ3ex8oq7Uo2SynCGwtqMRq1UaBJTVNqKqXM08RmoNZR+YkKcGL50SWHOyM75Oi7KEDSKWw9hrfJ0XznMHCMhZRN+D5JldnsSMt3uj1WneDMn+8KXz8fc4o/N3L7VEReqy4d4LPx8nBjmeD8i5XVic/NRY5yTE4UFLb7g0Aq12BRHSEHlERzf9xkRgTgZpGG87UWhATqcfSWcPw4vqj2FVYjX3FZsRHST+j+WlxGNrDhKyEKBTXNCnnbPVIikF2YjQiDTpY7U6cqmpAboq7v0kuYcne3HQCharNCIuqG5UALjEmErkpMdh4tAJ6nYBhPRKUpmb1RFaTzaFMa52Xn4Kc5BgM65GAPadrMDrXnTFrq/PyU/DmphNBD3aY2SEKcU6nqNTZ5YmKlvbakUfPWcYiApLjXMGOR8+O3K8zsleiu5m4nWUsedLKcxJLlqhqdr5lfG+kxBmVTI2U2ZFKU/mpsRAEAZNdJaNPd0h7BfVMioZeJyDPFeB4TmR5BjsbDp3RfH66ulEJ4BKjI9ArWXqegZnxiI7UK2vZ7ypjNdkceHLlQVgdTmSaotDblQl6ce5o/OvmMTi/T2rb/mJU5OM+DpTUtri5Y2djsEMU4tT9OvKkSK3F95uyfGZNrJHBDlFKrJQB9fxFe7JCChz6Z8Qre+LIwc6eUzV4ecPRFvevAYBKpV/He+Ot3LQcG6nHnRPzAbj7XvYVm5Xdi/PTpCBELhnJPXk9XcdnyPd79u2UmKVg55ze2oyLfEyGvAkjIJXZLh+Whb7pcZh/QR4AYJBrLaerG7HoPztx2fPf47UfCwAAt5yfqwxB5CTHYKqfp66nxBkxICMe6fFGFFb5Pp2+szHPTRTi1G+4CdEROFNrQb3F4fN6pUE5gj/eRClx3qex5EAhKyFK2dpBHhN/bMVe/HyiCpmmKFw9qofP51aak2O8Bzu9XBNOt17QW5kK65MWh0iDDnUWOw6USPvd5KdKTbzj81MQE6lXsrM9k6TH90uPw9cAfj5eidsn5Llfg+uIjBE9E1FRZ1WCoatHZeO9nwo9ylgRyEmOwepFFymPN0VFoG96HI6U1eGT7VI2KTXOiD9fMxTT/AxuvHn/zvOQGBPhc4K0K/DdkCjEqYMdOS1e11Jmx8rMDpHMV8+OXALKNEUph4jKgYG8F82PR8pbDHYqVc2/3tw/pR/OyUvGZUPdgUOEXocBGfHY4+qXidALSgYnKkKPC/ul4pu9UpOxfPv0oVl4fu0RrNlfphnhLpZfQ0IUzuuTgmPl9RiSbcLoXkl476dCHDtTrxyt4WuNL80djTUHyiCK0nvGzBHZzcboOyqYI+cyBjtEIc5bGavFnh0b99khksllrFqLHRa7A0aDHqIoKoFCVkI0SmulEldNo00zzr25oOWmWjmzk+zjl3lKnBEzRzQ/umhwlkkJdnolx8Cgd3eUTBmUoQQ7Oa7MzuBsE4Zkm7C3yIz/7irCvPN7AwBKzapgJz8FG4+U4+5JfZUeIrkXR68TfO6P0y8jXtnNOpyxZ4coxDkcqmAnRu7ZaSHYscgNyvy3DJEp2gCD63wsuZRV02hT+mLSTUYlY1rdIE1Oyf++KKxs1Jw+7kk5F6udmZAhPdwj3J5ngl0yMB2RBh3ijAYlswMA146RDtr8cFuhcps7YIvC0B4JWP/gxbh8eJay95D8PpEYHdwSUihgsEMU4tSHgMr7dvjK7NgcTuWsH+6zQwQIgqBkXuRSlhwkJMdGIipCr2lQlnt5ZJuP+d4MT97Dxtc0li/q/Wrk5mNZSpwR7995Ht7+9TjNOPtVI3sgQi/gl9Nm7C82w+kUUWaWMlAZpijNc2QmaD/3VcI6mzDYIQpx8iGgep2g7MtR7yOzIzc2Ahw9J5LJuyjL4+dyQJPpChISVKPnnuPcLe0PU9VKGcuXgVkmZXflfC/ngo3ulYSRrs0HZcmxkZjimtb6aNspVDZYYXU4IQjS7shqURF6pMa51xToHpzuiMEOUYiTMzvquruvMpbcnKzXCYjU88ebCGi+i3KJqrEXABKjpfsbrA6lOVkOYFo6xNLXuVitiTMa0N91VMNg11EYbSGXslbsKkJxtfQaUuOMyv5banIpC2h/5ikc8d2QKMTJPTt6QUCcK7Pjq4zVYJV3T9af9TV6Ipk8fu5ZxpKDnfgog5JpOeQaB582JBMGnYDT1Y0orPTetyOfeO5PMLFs7ii8OHc0hvVse7AzoV8qYiP1KKu1KGdgZXmUrGTZqnOwEqKZ2WGwQxTi5GksgyqzU9dKGYuTWERuSs+OKzgprdGWsXSqc6z2u4KdPmmxGO4KRDb5KGVVtbLPTkv6psfjMtfhn21lNOgxsb90MOj7P0kHonr268iyEt23M7PjZ7DT2NiIhgZ3pHvixAn8/e9/x7fffhuwhRGRxOGUGo71evcbsrnJ+z477mCHk1hEMvdeO1IZq9iszewA7r6do65DODMTojChr3Q8wkvrj6LW42eu0epQJrq6ch8ZeZflMte4vK/MTg9VGYsNyn4GO1dddRXefPNNAEB1dTXGjRuHZ555BldddRVeeumlgC6Q6GznGq6C3stUiSd1GYuIJHKDcqVHZkcdKMgBgTzNmJUQhfkX5CErIQoF5fVY/MkeiKo9r+SjIiL0QpdOPl48IA3qCrXn5JUsWxPssIzlV7Czfft2XHjhhQCAjz76CBkZGThx4gTefPNNPP/88wFdINHZzi5ndnQCUuPlc36smjdeGctYRM3J/0goV3p2pGMWMk3NMzuyDFMUkmIj8c9fjYJBJ+CL3cV4Z8tJ5X53v05kl/bHpcQZMaaX+yysTB9lrGxmdjT8CnYaGhoQHy91kn/77beYNWsWdDodzjvvPJw4cSKgCyQ628nHRRh0gpKOtzqcMDc279thGYuouVTV+VgNVrtyPIS3MhYAzTj3mNxkPDR9IADg76sPw+n6eexIv05HyaUsoIXMToK6Z4eZHb+Cnb59++Kzzz5DYWEhvvnmG0ydOhUAUFZWBpPJ1Mqjiag95GBHpxMQFaFHvKtJubze0uxalrGImkt2HRlxptaComopqxNnNCA+yh3gqLMfKbHace555/dGvNGA8joLdp2qBqAeO+/6rMmUQenKn7NUU1dqqXFGROiljJNn1ups5Fews2TJEjzwwAPo3bs3xo0bh/HjxwOQsjyjRo0K6AKJznbqzA4ApZRVXust2JGPimCwQyTrkRiNhOgINNoc+Nh1uneGyai5Rh0QeDb9Rhp0mDhAmoJa7Rr5bu1crM7UNz0O14zqgckD05WT1T3pdAKuH5uDETmJ6JcR5/Was4lfue5rr70WEyZMQHFxMUaMGKHcPnnyZFxzzTUBWxwRaTM7gJSSLyivV/oP1ORgJ5ZlLCJFpEGHmSOy8dbmE3hz43EAzTMiiaq9aLyVhqYMSseXu4uxZn8ZHpw2UGl2DkbzryAIeO6Gka1e9+drhnX+YroJv98RMzMzkZmZqbnt3HPP7fCCiEjLM7Mjn+JcXucls2NhGYvIm+vG9sRbm0+g3vUPAs+AJkFVjvLW9Dupfzp0AnCgpBanqhpQ3eDfuVgUHH4FO/X19fjrX/+KNWvWoKysDE7XtIjs2LFjAVkcEamPi5Cqzqnx2j1D1BpsLGMReTOsRwIGZMTjYKm0aaBnQKMuY3nL7CTFRmJs72T8VFCJNfvLcMZVRg5GGYvaz69g59e//jU2bNiAm2++GVlZWdyWnqgTOZSDQKXPU117hpzxUsZqZBmLyCtBEHDtmJ7481f7AXg5GbyFnh3ZlEHp+KmgEs98e1CZ6PLVM0Ohxa93xK+//hpffvklLrjggkCvh4g8KGdjyZmdON9lLPk0dGZ2iJq7elQP/HXlATicYrOAprUyFiCNfP/lqwMwN9khCMD88/OUk8gptPkV7CQlJSE5OTnQayEiL+ye01hxvstYja4yVqyRwQ6Rp7R4I+66qA++O3wG5+Rpf4e11qAMAH3S4jB7dE8UlNfhfy8bhLG9+Xuwu/Ar2PnTn/6EJUuW4I033kBMDFN4RJ3JKbpPPQfUmZ3mZSwlsxPBMhaRNw9MG4AHpg1odntSbASiI/QQIfrcuwYAnrl+hM/7KHT59Y74zDPP4OjRo8jIyEDv3r0REaHtRt++fXtAFkdE6gZlz2DH9z47nMYiah+jQY/X558DgGXgcORXsHP11VcHeBlE5IvTI9hJcZWxGqwONFjtmqMhWMYi8t+4/JRgL4E6SbuDHbvdDkEQcNttt6Fnz56dsSYiUvHM7MQZDTAadLDYnaiosyIm2f1jXG9xjZ6zjEVEpGj3cREGgwFPPfUU7PbmhxASUeA5XPtYyQ3KgiCoxs+1paxGno1FRNSMX2djXXLJJdiwYUOg10JEXjhce3bKx0UA3s/HEkVR2VQwhmUsIiKFX7nuGTNm4A9/+AP27NmDMWPGIDY2VnP/zJkzA7I4onDmdIqwOpyIimg5MPHM7ABAqmvXVvVEVpPNCdfglqaPh4jobOfXO+Ldd98NAHj22Web3ScIAhwOR8dWRXQW+O3b2/DT8UpsePBizVb1njwPAgXcE1nqvXYarO7ScnQrARQR0dnErzKW0+n0+cFAh6htdhRWo7rBhpMVDS1e57mpIOA+H6tcE+xIP3tRETqlmZmIiPwMdoio4+SMjd3jIF1f1+m9ZHbUZSz3HjssYRERqfn1rvj444+3eP+SJUv8WgzR2cTu6jyWgxlfHB47KANAipdprAZOYhEReeVXsPPpp59qPrfZbCgoKIDBYECfPn0Y7BC1gTuz00qw4zoI1KBXZ3aan4/F3ZOJiLzzK9jZsWNHs9vMZjNuvfVWXHPNNR1eFNHZQA5y2pzZUZWx0looY0WzjEVEpBGwnh2TyYTHHnsMDz/8cKCekiis2dua2XH6LmPVNNpQ5zr8Uy5jxTKzQ0SkEdAG5ZqaGtTU1ATyKYnCkiiKShDjaKVB2X1chPvHNSkmAvmp0v5Wb246DoBlLCIiX/zKdz///POaz0VRRHFxMd566y3MmDEjIAsjCmfq0pXd0XJmx30QqPs2QRBwzyV9seg/u/Cv747hlvG9WcYiIvLBr3fF5557TvO5TqdDWloa5s2bh8WLFwdkYUThTF26aq1nx1tmBwBmjsjGP9cewbHyeryw5jD2FZsBADHcUJCISMOvYKegoCDQ6yA6q2gyO23s2TF4bBRo0OvwP5P74f4PduKV744BAHQCcNGAtACvloioe/OrZ+e2225DbW1ts9vr6+tx2223dXhRROGuPZkdb8dFyK4ckY2+6XEAgH7pcfjk7gtw2bCsAK6UiKj78yvYeeONN9DY2Njs9sbGRrz55psdXhRRuGtPZsfbcREyvU7AW7efi+dvHIUv/mcCRuYkBnSdREThoF1lLLPZDFEUIYoiamtrERUVpdzncDjw1VdfIT09PeCLJAo36iMiWpvGcno5LkItKyEaM0dEB25xRERhpl3BTmJiIgRBgCAI6N+/f7P7BUHAY489FrDFEYUrfzI7PNyTiMg/7Qp21q1bB1EUcckll+Djjz9GcnKycl9kZCRyc3ORnZ0d8EUShRv1uHnrPTtS5sdbGYuIiFrXrmDnoosuAiBNY/Xq1QuCwDdfIn/Y27HPjny3jj9vRER+8atBOTc3Fz/88ANuuukmnH/++Th9+jQA4K233sIPP/wQ0AUShSOHpmenjZkdPYMdIiJ/+BXsfPzxx5g2bRqio6Oxfft2WCzSycs1NTX4y1/+EtAFEoUjux/77LBnh4jIP34FO0888QRefvll/N///R8iIiKU2y+44AJs3749YIsjClfanp2Wp7G8HQRKRERt51ewc/DgQUycOLHZ7QkJCaiuru7omojCHqexiIi6jl/BTmZmJo4cOdLs9h9++AH5+fkdXhRRuPNnB2UGO0RE/vEr2Lnjjjtw3333YcuWLRAEAUVFRXjnnXfwu9/9DnfddVeg10gUdvw5G4vBDhGRf/w6CPQPf/gDnE4nJk+ejIaGBkycOBFGoxEPPvggfv3rXwd6jURhx+5o+zSW+7gIv/5tQkR01vPr3VMQBPzxj39EZWUlfvnlF2zevBlnzpxBQkIC8vLyAr1GorDTnn123MdFdOqSiIjCVrvePi0WCxYvXoyxY8figgsuwFdffYXBgwdj7969GDBgAP7xj39g4cKFnbVWorDhcLZ9GsvdoMxoh4jIH+0qYy1ZsgSvvPIKpkyZgo0bN+K6667D/PnzsXnzZjzzzDO47rrroNfrO2utRGGjPfvsOEXfp54TEVHr2hXsfPjhh3jzzTcxc+ZM/PLLLxg+fDjsdjt27drFoyOI2qE9OyjLZS4dgx0iIr+0Ky9+6tQpjBkzBgAwdOhQGI1GLFy4kIEOUTv5s4MyMztERP5pV7DjcDgQGRmpfG4wGBAXFxfwRRGFO0d79tlxlbF4ECgRkX/aFeyIoohbb70Vs2bNwqxZs9DU1ITf/va3yufyR1t99913uPLKK5GdnQ1BEPDZZ581+3pLlixBVlYWoqOjMWXKFBw+fFhzTWVlJebOnQuTyYTExETcfvvtqKura8/LIupy6gmsNmd2eBAoEZFf2hXszJs3D+np6UhISEBCQgJuuukmZGdnK5/LH21VX1+PESNGYNmyZV7vf/LJJ/H888/j5ZdfxpYtWxAbG4tp06ahqalJuWbu3LnYu3cvVq1ahS+++ALfffcd7rzzzva8LKIu155pLG4qSETUMe1qUF6+fHlAv/iMGTMwY8YMr/eJooi///3v+H//7//hqquuAgC8+eabyMjIwGeffYY5c+Zg//79WLlyJbZu3YqxY8cCAF544QVcdtllePrpp5GdnR3Q9RIFik0V4LS2zw4PAiUi6piQ3bijoKAAJSUlmDJlinJbQkICxo0bh02bNgEANm3ahMTERCXQAYApU6ZAp9Nhy5YtPp/bYrHAbDZrPoi6Unt6duyuwIiZHSIi/4RssFNSUgIAyMjI0NyekZGh3FdSUoL09HTN/QaDAcnJyco13ixdulRTdsvJyQnw6ola1r6eHem/7NkhIvJPyAY7nWnx4sWoqalRPgoLC4O9JDrLtGsaS87ssIxFROSXkA12MjMzAQClpaWa20tLS5X7MjMzUVZWprnfbrejsrJSucYbo9EIk8mk+SDqStp9dtigTETUmUI22MnLy0NmZibWrFmj3GY2m7FlyxaMHz8eADB+/HhUV1dj27ZtyjVr166F0+nEuHHjunzNRG3Vnh2UGewQEXVMu6axAq2urg5HjhxRPi8oKMDOnTuRnJyMXr164f7778cTTzyBfv36IS8vDw8//DCys7Nx9dVXAwAGDRqE6dOn44477sDLL78Mm82Ge+65B3PmzOEkFoW09uygbGewQ0TUIUENdn7++WdcfPHFyueLFi0CIO3n8/rrr+P3v/896uvrceedd6K6uhoTJkzAypUrERUVpTzmnXfewT333IPJkydDp9Nh9uzZeP7557v8tRC1R3t6dtwHgYZsIpaIKKQFNdiZNGkSRNH3G70gCHj88cfx+OOP+7wmOTkZ7777bmcsj6jT2Ns1ei4fBNqpSyIiClt8+yQKArujbT07TqcI+d8DzOwQEfmH755EQdDWnh2HKvPJ0XMiIv8w2CEKgrb27Kjv03NTQSIivzDYIQqCtu6zow52DJzGIiLyC4MdoiBwqI6LcLRwEKg6KNKxjEVE5BcGO0RB0OaeHWZ2iIg6jMEOURC0dQdl+T5BAHQMdoiI/MJghygI2pvZ4SQWEZH/GOwQBYHd0cZpLJFHRRARdRSDHaIgaPM0loPBDhFRRzHYIQqCtvbsyIEQgx0iIv8x2CEKgrb27LgPAWWwQ0TkLwY7REGgzuaIonQGljdyIMTMDhGR/xjsEAWBZzbHV3bHzp4dIqIOY7BDFASefTq++nbcZSz+qBIR+YvvoERB0Dyz430iS76OsQ4Rkf/4FkoUBA6P4MZnZsfJzA4RUUfxHZQoCOyONvbsyJkdtuwQEfmNwQ5REHgGN74yOw5mdoiIOozvoERB4Bnc+MrsODh6TkTUYQx2iILAsyHZ4WCwQ0TUWRjsEAWBZ3DjaxqLwQ4RUccx2CEKgrb27HAHZSKijmOwQxQE7NkhIuo6DHaIgqDN01g8CJSIqMMY7BAFQdszO1IvDzM7RET+Y7BDFAQ2hxTEyBkbzx2VZTwIlIio4xjsEAWBnNmJitADaL6jsszJMhYRUYcx2CHqYqIoKmUro0H6EWxtGksnMNghIvIXgx2iLqaOa+Rgx1fPjnIQqJ7BDhGRvxjsEHUx9QaCRlcZi5kdIqLOw2CHqIupA5vWMjvug0AZ7BAR+YvBDlEXs3sJdnxNY7k3FeSPKhGRv/gOStTF1OdiGQ2uaaxWj4vo/HUREYUrvoUSdTGbK4sjCECEQd5np+UGZWZ2iIj8x3dQoi6m7sORgxhf++wws0NE1HF8CyXqYnJgY9DpVDsot9agzB9VIiJ/8R2UqItpMztSsONzGkvkcRFERB1lCPYCiM42SmlKL/g8G+udLSeQEB2hmsZisENE5C8GO0RdrLXMTlW9FX/89BdE6nW48dwcAAx2iIg6gmUsoi4m76Cs1wlee3bqLHYAgNXhxOnqJgDcVJCIqCMY7BB1MXXTsTKNpQp2LHaH8udTVQ0AeFwEEVFHMNgh6mJ2VR+Ot8xOk83dv1NYKQU7zOwQEfmPwQ5RF3OPngvQu04zV++zY7G7g516q5Tl0THYISLyG4Mdoi7mvWfHHeCoy1gyZnaIiPzHYIeoiyk9O3qd12ksdWZHxmksIiL/Mdgh6mJ21ei5t54di43BDhFRIDHYIepi8qnnevXZWD6msWQsYxER+Y/BDlEXay2zY/VaxuKPKhGRv/gOStTF1EdAuHt21A3K3oKdrlkbEVE44lsoUReTAxuD3kfPDjM7REQBxXdQoi7mzuzofOyz07xnh5kdIiL/8S2UqIupNxVs+zQWf1SJiPzFd1CiLmZ3tjaNJQU76uOwOI1FROQ/BjtEXUzeLTnCZ8+OVMbKTohWbuNBoERE/mOwQ9TF7OqenRamsfLTYpXbmNkhIvIfgx2iLuZo4w7KeanuYIc7KBMR+Y/BDlEXs3vdZ6d5GatXcgzkGIfBDhGR/xjsEHUxTWZH73sH5ZhIAzJMUQAY7BARdQSDHaIuZvd2Npaj+TSW0aDDdWNz0D8jDkOzE7p+oUREYcIQ7AUQnW3kaSyfPTuuMpYxQodFl/bHokv7d/0iiYjCCDM7RF3M1sZprEhum0xEFBB8NyXqYkrPjq99dlzTWMYIfdcvjogoDDHYIepi6uMiWprGMhr440lEFAgh/W766KOPQhAEzcfAgQOV+5uamrBgwQKkpKQgLi4Os2fPRmlpaRBXTNQ6bc+OznWb9wZlIiLquJB/Nx0yZAiKi4uVjx9++EG5b+HChVixYgU+/PBDbNiwAUVFRZg1a1YQV0vUOu87KHsLdljGIiIKhJCfxjIYDMjMzGx2e01NDV599VW8++67uOSSSwAAy5cvx6BBg7B582acd955Xb1UojbR9Ox42WfHYnNPYxERUceF/Lvp4cOHkZ2djfz8fMydOxcnT54EAGzbtg02mw1TpkxRrh04cCB69eqFTZs2tficFosFZrNZ80HUVbzvoOyexrI6WMYiIgqkkH43HTduHF5//XWsXLkSL730EgoKCnDhhReitrYWJSUliIyMRGJiouYxGRkZKCkpafF5ly5dioSEBOUjJyenE18FkZbXs7FcTcuiKLKMRUQUYCFdxpoxY4by5+HDh2PcuHHIzc3Ff/7zH0RHR/v9vIsXL8aiRYuUz81mMwMe6jI2V+bG29lYNocI0VXRYhmLiCgwutW7aWJiIvr3748jR44gMzMTVqsV1dXVmmtKS0u99vioGY1GmEwmzQdRV9FmdrTTWPLYOcBNBYmIAqVbvZvW1dXh6NGjyMrKwpgxYxAREYE1a9Yo9x88eBAnT57E+PHjg7hKopa1NI0ll7AA9uwQEQVKSJexHnjgAVx55ZXIzc1FUVERHnnkEej1etx4441ISEjA7bffjkWLFiE5ORkmkwn33nsvxo8fz0ksCmkt7aCsHBVh0EEQeNI5EVEghHSwc+rUKdx4442oqKhAWloaJkyYgM2bNyMtLQ0A8Nxzz0Gn02H27NmwWCyYNm0aXnzxxSCvmqhldqe3HZSlIEcZO2dWh4goYEI62Hn//fdbvD8qKgrLli3DsmXLumhFRB0n76Cs1zXfZ4eTWEREgcd/PhJ1MffZWL57dpjZISIKHL6jEnUxh2pTQXkaSxQBp1Pk7slERJ2A76hEXcxbz458u3v3ZJaxiIgChcEOUReTm5H1qmksQMr4WGwsYxERBRrfUYm6mLtnxzOz49SMnhMRUWDwHZWoi2l7djwyO3aOnhMRBRrfUYm6mBzsROh1zXp2OHpORBR4DHaIuphdldkRBHcpy8FpLCKiTsF3VKIupj4IFIBmrx3us0NEFHh8RyXqYnbVDsqAO+hxOFjGIiLqDAx2iLqYO7Mj/fipz8digzIRUeDxHZWoi6l7dgBoTj63ypkd9uwQEQUM31GJuph6nx0A0LsyPJzGIiLqHAx2iLqYz54d7qBMRNQp+I5K1MWUnh29t2ks9uwQEQUa31GJupjdo0FZDnocquMiGOwQEQUO31GJupDTKUKUYp3m++xw9JyIqFMw2CHqQnJWB5BOPQc8enbs3EGZiCjQ+I5KHdJkc8Cp+gVOLXOo/q68TmOxQZmIKOD4jkp+q6izYNxf1uA3b28L9lK6DXkSC/AxjcUyFhFRwDHYIb/9fKIKNY02bD1eGeyldBvyHjuAtx2UOY1FRNQZ+I5KfjtcWgsAqGm0tbuU1Wh1dMaSQp66Z8cV46gyO07uoExE1An4jkp+O1RaBwAQRaDWYm/z497adBxDHlmJ1ftKO2tpIUt94rkgtHTqOctYRESBwmCH/HbIldkBgJoGm8/rlv9YgJW/FCufbzhUDqcolcHONp67JwPqfXbcwU4ky1hERAFjCPYCqG0arQ5ER4bOv/btDieOnalXPq9p9B7sHD1Th8dW7ENMpB5TB2dCpxNwslJ6XEWdpUvWGkrkzE6E3h3MKNNYDhEWG3t2iIgCje+o3cCTKw9g+GPfYM+pmmAvRXGisgFWh3uyqLrR6vW6A8VS9qfB6sDp6kY4nSJOVDQAACrrvT8mnNlcDcqqxA6nsYiIOhmDnW5g07EK2Bwifmrn1NPrPxbg6z3FrV/oh8OqEhYAVLvKWIdKa/G3lQdQ2+T+XFZQXo+yWovyC738LAx2qhqk15wQE6HcJpe0LA6n0sDMzA4RUeCwjNUNnKmVyj1F1Y1tfkxhZQMeXbEPURE6TB2SqekRCQS5OVkml7GeX3MYX+wuRlJMBO6c2AeHy9zBzrEzdZpf4pX1Z18ZS/4e9kiMVm6TMzuNVneTN6exiIgCh++oIU4URb+CneMVUl9Mk82JU1UNAV/X4TLvwU5xTRMAYPuJagDaoOhYeT1OVLrXUlF39mV2iqqlv5/sBHewIwei9Rb3OH6knj+aRESBwnfUEFdrsStln/YEO6eq3NceK69v4Ur/yGWsvulxANzBjtx0vLOwGla7E8dVX7ugvB4nK9zBToPVcdbttyN/D7O9ZHYaXJkdg06AgcEOEVHA8B01hDRYm+9VU2Z2l3qKXFmTtlBnc9RTU4GgnsQ6p3cyAKDa1YtS7srWlJibsOlYhWYTvWNn6pWMk6yiDaWsJpsDohge5295C3aiI6Vqshygsl+HiCiw+K4aIr7YXYQhj3yD9386qbldLmHJf5aPE2iNJrNzpq6FK9vveIU0iRUTqcfgrHgAUmanyeZAnWpzwf/8XAgA6J0SAwA4Xd2oaVgGWp/I+qmgEmOfWI2HPt4dyJcQNKeVYCdKue28fClgXH/wDADAGMFJLCKiQGKwEyI2HDwDUQRW79fuKnzGYy+akjZmd9TBTkGAylh7TtXgDx/vxmMr9gIA+qXHITEmEoA0jaUOzABg1V7ptYzLS0Gia/pI7uGJcjXgttS3U15nwb3vbUedxY4fDpcH5DUEm9zTpM7sTOqfDr1OQKNrjx326xARBRbfVUOE3Fezr8isud0zgDjt0bfjdIposjXP9hRWBr6MtfTr/Xh/ayG+dwUeQ3skKEFMTaMN5R6BmbwPT7+MOOSlxmruG9YjAQBQ4crsiKKoOV/L4RSx8IOdKHWV8UrMTbCr9vXpjuosdqW3KSvBndlJiInAOb2TlM85iUVEFFh8Vw0RcqmpqKYJVarSjmewI0/zyG5+bQvO/+tamJvcOxg32RwoUz2uxNyE+nacXeWLnJW57YI8LLliMBZd2h8J0e5gR87SxEdpdzTonxGP/NQ45fO0eCN6JkmlrYo6C6x2J6Y8uwFXLftRCXje33oS3x8uR1SEDgadAKcIlNZ271H1YlegaooyID4qQnPflEEZyp/Zs0NEFFh8Vw0BVfVWVKnOltpX7M7ulNVqg5tiVWanwWrHj0cqUFlvxcESdy+M3AQbE6lHSqxUZupoKcvc5M7cLLy0H26bkIeUOCMSo91lLPn+0b2SEG90Bzz9M+KRn+bO7OQmxyjrqqy3oqC8HkfP1GPP6RocdQV96w5I/Sv3XNwXWa7+lvZMo4Wi016ak2WTNcEOe3aIiAKJwU4I8BwNV5ey5MxOTrL0C7Koxv0L/4hqrxt1ICD36/RMilaCjI6Onxe4SmFp8UZNVkLeCbjR5lCmxdLjjRiRkwhAyvJkmIzIV5WxeqXEIDlOCnbK66yaBuodhdUQRRE7C6sBAOP7pCh70nT3YMdbv44sLzUWfVzfK2Z2iIgCi++qIcBzWmpvkfsMLDnYGdEzEQBwWlXGUm/Yp+7lKXSNneckxSi9Mh2dyDpWLj0+36P3Jt5ogODanFnOyqTGGzHSFez0z4iHIAjIT3OXsXqnxCI11ghAGj1XB2I7C6txuroR5XUWGHQChmQnKLsNe5bwupsiL5NYanIpiyeeExEFFt9VQ4BcYpJ/qavLWHJpSA521NkN9flUvjM7cZqv4enznafxVRvOz5IzO+pyFADodILSt3PUlWlKjTNi9pie6Jceh1+d2wsAkJsSowRFuSkxSFaVsdQN1DtPVitZnUFZJkRF6JVMSHfP7LRUxgKAOef2Qq/kGEwfmtmVyyIiCns8G6uLNFjtiIn0/tct/7K/YngWXvnuGI6eqUeTzQGDTlCmleSyUHF1I0RRhCAImj1rilVZD3ewE4Nerj1uvE1klZmbcP8HO6EXBFzYL7VZ06zaUVewpG40liVER6C6waZkaFLjIpGXGotViy5SromK0KNPWhyOlNWhf0a8MkFWUWeFQefOOh0oMePHIxUAoGSHwqVnx9u5WGp5qbH47vcXd+WSiIjOCszsdIF3t5zE4CXf4P73d2gmrWRy1uW8PilIjo2EwyniYEktKuutEEVAJwBDsk0AgHqrA+ZGabLKVxlL3j25Z1K00gdy7Exds12It5+shigCdqeI4+Utn591zEdmBwASXZkdq+tYi9Q4o9fneHHuaLx802gMyjIhxVXGKq9zl7H0rqmrz3eeBuAOduRMiOfYfXcj9+xkJXgPdoiIqHMw2OkCGw6VAQA+21mES5/7DluPVyr3OZwiClxHKPRJjVOCmn3FZmV8PCXOiFijQSn9nK5uRL3Frvnl762MlZMcg17JsdAJUpDkOca+o7BK+bPck6Ne10vrj2LLsQo4nSIKXPd77pcDAKZobUbIV7DTPyMe04dmuV6T9FosdieqXZNoE/qmApDOzAKAUb0SAbgzIcXtOC5D1mRz4O+rDwV8F+n2cjpFJfvmq2eHiIg6B4OdLiBnRZJiIlBeZ8Gfvtin3FdU3Qir3YlIvQ49kqIxOEsKdvYW1SjBSXq8FDxkq8o58qnj8oi3ucmOOosdTTZ3UNMzKRqRBh16p0gBytbj7uAGkPpjZEc9ylyf7zyNv608gAXvbsepqkY02Zww6ATkJMc0e33yLsqy1LjIZtd4ionUa6aOeiRGY3yfFOXzhOgIJbCSN+CrabShzmKH0ynC1sYNBt/efAJ/X30YT3y5v03Xd5byegusDid0ApBhYrBDRNSVGOx0ModTxAnXSd/LfjUaAHCguFYp+cglnNyUGOh1Aga7Mjt7TrmDnTQ52EmQMxzuM6aG9UyAybWJX3F1o5LViTMalMZhueH1o22FmnXtOe2e+vJsYP7w51MApNHw134sACCNjEd4OcogIdrdi6QTmgc/3giCoMkA5afFKmUrQOpRElwdzfFREcpGhcXVjVj69X4MeeQb7C/W7jbtzbYTUoC3/WRVUA8TlSfJMkxRXv8OiYio8/Bdt5OdrmqE1eFEpEGHcfkpiI8ywOpwKmPacnlF7oU5Ny8ZggDsOlWj/KJOi5MzO3LvSpOyx07/jHhNT4u6X0cOFq4d0xMAsOHQGZSapV+6h0prlXKReh2AdNTEpmMVyufvbpEOJ/UcO5fJGwsCQHKsEXqd0Ka/G7ksB0jlsWE9EiA/VB34AO5S1omKBrz3UyGsdie+2F3U6teQJ7uqG2w4XtFyX1JnkjeDVB8TQUREXYPBTic7Kve6pMRKmRulTCVlJeQSV55ryikrIVrpXfl0h9SoK2d25LLO5ztPK30//TLiNPvQyEFQL1W5KT8tDmNyk+AU3c8pBwHZrl++BeX1Subj4+1SVkc+rVw+40q9V46afD4W0LYSlkwd7OSnxiLWaFCmzuSTwGVyQPfpztPKyeqbjlagJaXmJk2fz87Cqhau7lzfH5HOE+vlpQxIRESdi8FOJ3MHM1KgIpep5F2Sj3pkdgB3JkYOMuRgZ/aYnshLjUVxTRN2uPpt1JmdoupGbHZlZMbkug+WBIDrXM/54c+FEEURO05Kv/ivGJENvU5Ag9WBUrMFTqeIj7ZJwc79U/orB3YCvjM76gZlea1tkaIKjORA6h83jMK/bxmL8/ukaq6VMyLf/FKi3Lb7VE2LZ37tUPUkAdoepa50qqoBH/4slRDnuPYdIiKirsNgp5PJU0xyMKNuQG6w2pVSlbxpIABMG5KpOUwzPV76RR9nNGDZr0ZrGnv7p8cr+9CcqmrAlgIp46Nu9gWAy4dnISpCh6Nn6rHpaIWS2Rmbm6RkG46dqcPmggqcqmpEvNGAaUMycd3YnspzeJvEAtyj54DvSSxvUjzKWIDUFzRlcEaza+WAzu46KFQQpD//fEKbrVn5SzGW/1ggBXSuTI78dXa4XrMvoijizU3H8emOU21a/46TVXhu1SGvp86rLVt3FDaHiPH5KTgvP6XFa4mIKPAY7HQy9/40UuZiSLaUKdlXbMb3h8thsTvRMyka/TPcJaKoCD2uHJGtfK7OlgzONuGxmUMASCWRhJgIpYy14dAZ1DbZEW80KEGVLD4qApcPk57z1uVblWmukb0SlYzNsfJ6JatzxYhsREfqMXNENqIj9Ig06NAvI97ra0xQBTvqAKY1Ka7AyGjQ+dxoT6a+P9Kgw2WuEfbNqt6ikxUNuOfdHXhsxT6s3l+mZHLmjpOyKfuLzS0GJm9vOYkln+/Fwg92aQ5W9abJ5sBdb2/HP9Ycxssbjvq8rrDSndVZeGn/Fp+TiIg6B4OdTuZZxuqbHocIvYDaJjve3HQcgHQmktxMLJPLTkDz0tAN5+Tg1Xlj8a9bxgBwZz3kk9PPzUuGwcvEz/+7fBAuGZgOq8MJUZQCiPT4KGVte07V4Os9UplIzugkxkTig9+ch3d+PU7TY6Omnr5KbUcZS36+vNRY6FppalYfsTChbyouHpgOQBvs/HPdYSXz89yqQ8q02RUjspEaFwmbQ1R6pTz9croGf1rh3hLgH2sOtbieD7YWosTV7P3qDwWoabQ1u0YURTz5zUHYnSIu6JuCc/OSm11DRESdj8FOJ6q32JVfiPJOxpEGHfqlSxkS+VgE+QBItZE5ibhqZDYuHpDWrKlVEARMHpSBgZlS9sbzrCVfpZKk2Ei8Om8snr1+BHKSo3HTebkA3FmnT3ecRqPNgfy0WIxSTUMN75mIc3r7/kWd4GcZ6/w+KchLjcV1Y3NavVY9xTR5ULrSwLz7VA3qLHacqKjHx9ul5utIgw77is1osDoQZzSgT1qcMt2142QVPtl+Cs+tOgRzkxSglNQ04e53tsPqcGJ0r0QIAvDVnhLNaLvV7sSL64/g270laLI58OL6I8rXqm2y49UfCpqt+YOthVixqwh6nYAHpw1s898LEREFFs/G6kTy3jVJMRGa7MeQbJNy2Ge80eD1X/yCIOAfc0a16etkxBuhEwBXUqNZv47n884a3ROzRjfvxZEboq8bk9Ms09QSf6exeibFYN0Dk9p0bWZCFExRBjTZnJg8MAOZCVHISY5GYWUjVu0rwYaDZ+BwiriofxqGZJvw4nqptDQiJwF6nYCROYlYvb8MT31zEBbXHkf/+bkQ14/NwWs/FqC2yY4eidFYfuu5+N/P9uDL3cX4x+rDePlmKXv2+sYCPLnyIAApO1dqtiA7IQq/nz4Q93+wE8t/KMDtF+QhwfV3sa/IjCX/3QsAeGDqgGaj9ERE1HWY2elE8oaBniPb8kQWAEzsn4ZIQ8e+DQa9DpmuXXlNUQYM8ujXaU0f1SSYTgBmje7RrsdHRbh3Q25PZqc9IvQ6vP3rcXjvznHIdGV5xrsyWAs/2IXPdkp77iy8tD/uuDAfca6dpeUgY1QvaTrNYncqPULFNU34x5rDqG2yY0ROIt66/VwkxETg/sn9IAjAyr0l2Hq8Eg1WO17ZcExZizzev+CSvpg5IhsDM+NRa7Hjnve2o6SmCesPlmH+6z/Banfi4gFp+M3E/E75OyEiorZhZqcTFcjNyR5TTOrm4SmD0wPytbISo1FU04Rz81LavKmfLC3eiDijAXUWOyb2T/PrOINZo3tif7EZ/TK878UTCMNVE2sAcP3YHKw9UIbaJjsEAbhmVE8luPnj5YPw8oajuGaUFLiNyU3CiJ4JMEVH4LGZQ5CVEI2nvz2Ir/YUY975vfHrCXlKn1O/jHhcO7onPtx2Cve+uwNXjcxGRb0VuSkxeOHGUfjzl/thjNDjujE50OkE/L/LB+O217fi+8PlmPT0OjTZ5H2JYvHs9SNb7UciIqLOJYjB3EM/RJjNZiQkJKCmpgYmU/uyIi257/0d+HxnEX4/fQDuntRXub22yYZz/7wGTlHE5sWTkdSOCSZfFn+yB+/9dBJ/unoobnb14rTHDa9swpaCSrx802jlsM6zWZ3Fjpn//EFpMAeAp64d7rO/6HBpLR74aDd2FVZDEIDbLsjDA1MHIDpS31VLJiI667T19zczO51IGTtP1WY74qMi8M4d4yAAAQl0AODBaQNwQd8UzPAzUHn6uhE4UFKLS73scXM2ijMa8OLc0bh62Y9osjnROyVGyRJ50y8jHh//djy+3FOMvNTYZlkoIiIKHgY7ncjmcEIQtD0xstG9krw8wn/JsZG4Ynh26xf6kJMc4/VE87PZwEwTnrx2BJZ+tR+PXDnE6zi/mkGvw1Uj29fvREREnY9lLHReGQuQNp+L0Ova3UdDRERELWMZK0RERbBng4iIKJg4ek5ERERhjcEOERERhTUGO0RERBTWGOwQERFRWGOwQ0RERGEtbIKdZcuWoXfv3oiKisK4cePw008/BXtJREREFALCItj54IMPsGjRIjzyyCPYvn07RowYgWnTpqGsrCzYSyMiIqIgC4tg59lnn8Udd9yB+fPnY/DgwXj55ZcRExOD1157LdhLIyIioiDr9sGO1WrFtm3bMGXKFOU2nU6HKVOmYNOmTV4fY7FYYDabNR9EREQUnrp9sFNeXg6Hw4GMDO0BlhkZGSgpKfH6mKVLlyIhIUH5yMnxfpI1ERERdX/dPtjxx+LFi1FTU6N8FBYWBntJRERE1Em6/dlYqamp0Ov1KC0t1dxeWlqKzMxMr48xGo0wGo1dsTwiIiIKsm6f2YmMjMSYMWOwZs0a5Tan04k1a9Zg/PjxQVwZERERhYJun9kBgEWLFmHevHkYO3Yszj33XPz9739HfX095s+f36bHi6IIAGxUJiIi6kbk39vy73FfwiLYueGGG3DmzBksWbIEJSUlGDlyJFauXNmsadmX2tpaAGCjMhERUTdUW1uLhIQEn/cLYmvh0FnA6XSiqKgI8fHxEAQhYM9rNpuRk5ODwsJCmEymgD1vKAn31xjurw/gawwH4f76AL7GcNAZr08URdTW1iI7Oxs6ne/OnLDI7HSUTqdDz549O+35TSZTWP6PqxburzHcXx/A1xgOwv31AXyN4SDQr6+ljI6s2zcoExEREbWEwQ4RERGFNQY7nchoNOKRRx4J6z19wv01hvvrA/gaw0G4vz6ArzEcBPP1sUGZiIiIwhozO0RERBTWGOwQERFRWGOwQ0RERGGNwQ4RERGFNQY7nWjZsmXo3bs3oqKiMG7cOPz000/BXpJfli5dinPOOQfx8fFIT0/H1VdfjYMHD2qumTRpEgRB0Hz89re/DdKK2+/RRx9ttv6BAwcq9zc1NWHBggVISUlBXFwcZs+ejdLS0iCuuP169+7d7DUKgoAFCxYA6H7fw++++w5XXnklsrOzIQgCPvvsM839oihiyZIlyMrKQnR0NKZMmYLDhw9rrqmsrMTcuXNhMpmQmJiI22+/HXV1dV34KlrW0mu02Wx46KGHMGzYMMTGxiI7Oxu33HILioqKNM/h7fv+17/+tYtfiXetfQ9vvfXWZmufPn265pru/D0E4PVnUhAEPPXUU8o1ofw9bMvvh7a8f548eRKXX345YmJikJ6ejgcffBB2uz1g62Sw00k++OADLFq0CI888gi2b9+OESNGYNq0aSgrKwv20tptw4YNWLBgATZv3oxVq1bBZrNh6tSpqK+v11x3xx13oLi4WPl48skng7Ri/wwZMkSz/h9++EG5b+HChVixYgU+/PBDbNiwAUVFRZg1a1YQV9t+W7du1by+VatWAQCuu+465Zru9D2sr6/HiBEjsGzZMq/3P/nkk3j++efx8ssvY8uWLYiNjcW0adPQ1NSkXDN37lzs3bsXq1atwhdffIHvvvsOd955Z1e9hFa19BobGhqwfft2PPzww9i+fTs++eQTHDx4EDNnzmx27eOPP675vt57771dsfxWtfY9BIDp06dr1v7ee+9p7u/O30MAmtdWXFyM1157DYIgYPbs2ZrrQvV72JbfD629fzocDlx++eWwWq3YuHEj3njjDbz++utYsmRJ4BYqUqc499xzxQULFiifOxwOMTs7W1y6dGkQVxUYZWVlIgBxw4YNym0XXXSReN999wVvUR30yCOPiCNGjPB6X3V1tRgRESF++OGHym379+8XAYibNm3qohUG3n333Sf26dNHdDqdoih27+8hAPHTTz9VPnc6nWJmZqb41FNPKbdVV1eLRqNRfO+990RRFMV9+/aJAMStW7cq13z99deiIAji6dOnu2ztbeX5Gr356aefRADiiRMnlNtyc3PF5557rnMXFwDeXt+8efPEq666yudjwvF7eNVVV4mXXHKJ5rbu8j0Uxea/H9ry/vnVV1+JOp1OLCkpUa556aWXRJPJJFosloCsi5mdTmC1WrFt2zZMmTJFuU2n02HKlCnYtGlTEFcWGDU1NQCA5ORkze3vvPMOUlNTMXToUCxevBgNDQ3BWJ7fDh8+jOzsbOTn52Pu3Lk4efIkAGDbtm2w2Wya7+fAgQPRq1evbvv9tFqtePvtt3HbbbdpDr/t7t9DWUFBAUpKSjTfs4SEBIwbN075nm3atAmJiYkYO3ascs2UKVOg0+mwZcuWLl9zINTU1EAQBCQmJmpu/+tf/4qUlBSMGjUKTz31VEDLA51t/fr1SE9Px4ABA3DXXXehoqJCuS/cvoelpaX48ssvcfvttze7r7t8Dz1/P7Tl/XPTpk0YNmwYMjIylGumTZsGs9mMvXv3BmRdPAi0E5SXl8PhcGi+cQCQkZGBAwcOBGlVgeF0OnH//ffjggsuwNChQ5Xbf/WrXyE3NxfZ2dnYvXs3HnroIRw8eBCffPJJEFfbduPGjcPrr7+OAQMGoLi4GI899hguvPBC/PLLLygpKUFkZGSzXyAZGRkoKSkJzoI76LPPPkN1dTVuvfVW5bbu/j1Uk78v3n4G5ftKSkqQnp6uud9gMCA5Oblbfl+bmprw0EMP4cYbb9Qcsvg///M/GD16NJKTk7Fx40YsXrwYxcXFePbZZ4O42raZPn06Zs2ahby8PBw9ehT/+7//ixkzZmDTpk3Q6/Vh9z184403EB8f36xE3l2+h95+P7Tl/bOkpMTrz6p8XyAw2KF2WbBgAX755RdNPwsATY182LBhyMrKwuTJk3H06FH06dOnq5fZbjNmzFD+PHz4cIwbNw65ubn4z3/+g+jo6CCurHO8+uqrmDFjBrKzs5Xbuvv38Gxms9lw/fXXQxRFvPTSS5r7Fi1apPx5+PDhiIyMxG9+8xssXbo05I8lmDNnjvLnYcOGYfjw4ejTpw/Wr1+PyZMnB3FlneO1117D3LlzERUVpbm9u3wPff1+CAUsY3WC1NRU6PX6Zt3mpaWlyMzMDNKqOu6ee+7BF198gXXr1qFnz54tXjtu3DgAwJEjR7piaQGXmJiI/v3748iRI8jMzITVakV1dbXmmu76/Txx4gRWr16NX//61y1e152/h/L3paWfwczMzGYDA3a7HZWVld3q+yoHOidOnMCqVas0WR1vxo0bB7vdjuPHj3fNAgMoPz8fqampyv+T4fI9BIDvv/8eBw8ebPXnEgjN76Gv3w9tef/MzMz0+rMq3xcIDHY6QWRkJMaMGYM1a9YotzmdTqxZswbjx48P4sr8I4oi7rnnHnz66adYu3Yt8vLyWn3Mzp07AQBZWVmdvLrOUVdXh6NHjyIrKwtjxoxBRESE5vt58OBBnDx5slt+P5cvX4709HRcfvnlLV7Xnb+HeXl5yMzM1HzPzGYztmzZonzPxo8fj+rqamzbtk25Zu3atXA6nUqgF+rkQOfw4cNYvXo1UlJSWn3Mzp07odPpmpV/uoNTp06hoqJC+X8yHL6HsldffRVjxozBiBEjWr02lL6Hrf1+aMv75/jx47Fnzx5N4CoH7oMHDw7YQqkTvP/++6LRaBRff/11cd++feKdd94pJiYmarrNu4u77rpLTEhIENevXy8WFxcrHw0NDaIoiuKRI0fExx9/XPz555/FgoIC8fPPPxfz8/PFiRMnBnnlbfe73/1OXL9+vVhQUCD++OOP4pQpU8TU1FSxrKxMFEVR/O1vfyv26tVLXLt2rfjzzz+L48ePF8ePHx/kVbefw+EQe/XqJT700EOa27vj97C2tlbcsWOHuGPHDhGA+Oyzz4o7duxQJpH++te/iomJieLnn38u7t69W7zqqqvEvLw8sbGxUXmO6dOni6NGjRK3bNki/vDDD2K/fv3EG2+8MVgvqZmWXqPVahVnzpwp9uzZU9y5c6fmZ1OeYNm4caP43HPPiTt37hSPHj0qvv3222JaWpp4yy23BPmVSVp6fbW1teIDDzwgbtq0SSwoKBBXr14tjh49WuzXr5/Y1NSkPEd3/h7KampqxJiYGPGll15q9vhQ/x629vtBFFt//7Tb7eLQoUPFqVOnijt37hRXrlwppqWliYsXLw7YOhnsdKIXXnhB7NWrlxgZGSmee+654ubNm4O9JL8A8PqxfPlyURRF8eTJk+LEiRPF5ORk0Wg0in379hUffPBBsaamJrgLb4cbbrhBzMrKEiMjI8UePXqIN9xwg3jkyBHl/sbGRvHuu+8Wk5KSxJiYGPGaa64Ri4uLg7hi/3zzzTciAPHgwYOa27vj93DdunVe/7+cN2+eKIrS+PnDDz8sZmRkiEajUZw8eXKz111RUSHeeOONYlxcnGgymcT58+eLtbW1QXg13rX0GgsKCnz+bK5bt04URVHctm2bOG7cODEhIUGMiooSBw0aJP7lL3/RBAvB1NLra2hoEKdOnSqmpaWJERERYm5urnjHHXc0+wdjd/4eyl555RUxOjparK6ubvb4UP8etvb7QRTb9v55/PhxccaMGWJ0dLSYmpoq/u53vxNtNlvA1im4FktEREQUltizQ0RERGGNwQ4RERGFNQY7REREFNYY7BAREVFYY7BDREREYY3BDhEREYU1BjtEREQU1hjsEFG3cfz4cQiCoBxl0RluvfVWXH311Z32/ETU9RjsEFGXufXWWyEIQrOP6dOnt+nxOTk5KC4uxtChQzt5pUQUTgzBXgARnV2mT5+O5cuXa24zGo1teqxer+92p1kTUfAxs0NEXcpoNCIzM1PzkZSUBAAQBAEvvfQSZsyYgejoaOTn5+Ojjz5SHutZxqqqqsLcuXORlpaG6Oho9OvXTxNI7dmzB5dccgmio6ORkpKCO++8E3V1dcr9DocDixYtQmJiIlJSUvD73/8enifoOJ1OLF26FHl5eYiOjsaIESM0a2ptDUQUfAx2iCikPPzww5g9ezZ27dqFuXPnYs6cOdi/f7/Pa/ft24evv/4a+/fvx0svvYTU1FQAQH19PaZNm4akpCRs3boVH374IVavXo177rlHefwzzzyD119/Ha+99hp++OEHVFZW4tNPP9V8jaVLl+LNN9/Eyy+/jL1792LhwoW46aabsGHDhlbXQEQhImBHihIRtWLevHmiXq8XY2NjNR9//vOfRVGUTlD+7W9/q3nMuHHjxLvuuksURVE56XvHjh2iKIrilVdeKc6fP9/r1/rXv/4lJiUliXV1dcptX375pajT6ZSTs7OyssQnn3xSud9ms4k9e/YUr7rqKlEURbGpqUmMiYkRN27cqHnu22+/XbzxxhtbXQMRhQb27BBRl7r44ovx0ksvaW5LTk5W/jx+/HjNfePHj/c5fXXXXXdh9uzZ2L59O6ZOnYqrr74a559/PgBg//79GDFiBGJjY5XrL7jgAjidThw8eBBRUVEoLi7GuHHjlPsNBgPGjh2rlLKOHDmChoYGXHrppZqva7VaMWrUqFbXQEShgcEOEXWp2NhY9O3bNyDPNWPGDJw4cQJfffUVVq1ahcmTJ2PBggV4+umnA/L8cn/Pl19+iR49emjuk5uqO3sNRNRx7NkhopCyefPmZp8PGjTI5/VpaWmYN28e3n77bfz973/Hv/71LwDAoEGDsGvXLtTX1yvX/vjjj9DpdBgwYAASEhKQlZWFLVu2KPfb7XZs27ZN+Xzw4MEwGo04efIk+vbtq/nIyclpdQ1EFBqY2SGiLmWxWFBSUqK5zWAwKE29H374IcaOHYsJEybgnXfewU8//YRXX33V63MtWbIEY8aMwZAhQ2CxWPDFF18ogdHcuXPxyCOPYN68eXj00Udx5swZ3Hvvvbj55puRkZEBALjvvvvw17/+Ff369cPAgQPx7LPPorq6Wnn++Ph4PPDAA1i4cCGcTicmTJiAmpoa/PjjjzCZTJg3b16LayCi0MBgh4i61MqVK5GVlaW5bcCAAThw4AAA4LHHHsP777+Pu+++G1lZWXjvvfcwePBgr88VGRmJxYsX4/jx44iOjsaFF16I999/HwAQExODb775Bvfddx/OOeccxMTEYPbs2Xj22WeVx//ud79DcXEx5s2bB51Oh9tuuw3XXHMNampqlGv+9Kc/IS0tDUuXLsWxY8eQmJiI0aNH43//939bXQMRhQZBFD02lSAiChJBEPDpp5/yuAYiCij27BAREVFYY7BDREREYY09O0QUMlhVJ6LOwMwOERERhTUGO0RERBTWGOwQERFRWGOwQ0RERGGNwQ4RERGFNQY7REREFNYY7BAREVFYY7BDREREYY3BDhEREYW1/w/+7a2OxN5uzwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title(f'SAC on {env_name}')\n",
    "plt.show()\n",
    "\n",
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(episodes_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title(f'SAC on {env_name}')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d860264",
   "metadata": {},
   "outputs": [],
   "source": [
    "rl_utils.play_game(env_name, agent)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
